mercurial/copies.py
author Martin von Zweigbergk <martinvonz@google.com>
Tue, 15 Sep 2020 23:19:14 -0700
changeset 45502 aad11a26a054
parent 45014 cfd06649a1b8
child 45627 fb000408bca5
permissions -rw-r--r--
mergestate: simplify reset(), knowing that `other` and `node` go together There's only one caller of `reset()` that passes any arguments at all, and that originates from `merge.py:1371`. That code always passes values for both `node` and `other`. Differential Revision: https://phab.mercurial-scm.org/D9032
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
6274
f3f383efbeae copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
     1
# copies.py - copy detection for Mercurial
f3f383efbeae copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
     2
#
f3f383efbeae copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
     3
# Copyright 2008 Matt Mackall <mpm@selenic.com>
f3f383efbeae copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
     4
#
8225
46293a0c7e9f updated license to be explicit about GPL version 2
Martin Geisler <mg@lazybytes.net>
parents: 8209
diff changeset
     5
# This software may be used and distributed according to the terms of the
10263
25e572394f5c Update license to GPLv2+
Matt Mackall <mpm@selenic.com>
parents: 10262
diff changeset
     6
# GNU General Public License version 2 or any later version.
6274
f3f383efbeae copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
     7
25924
cfc24c22454e copies: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25289
diff changeset
     8
from __future__ import absolute_import
cfc24c22454e copies: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25289
diff changeset
     9
34191
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34095
diff changeset
    10
import collections
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34095
diff changeset
    11
import os
6274
f3f383efbeae copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
    12
34846
f05a6e015ecc copies: add a config to limit the number of candidates to check in heuristics
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34787
diff changeset
    13
from .i18n import _
f05a6e015ecc copies: add a config to limit the number of candidates to check in heuristics
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34787
diff changeset
    14
43148
843da18386d5 sidedatacopies: deal with upgrading and downgrading to that format
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43147
diff changeset
    15
843da18386d5 sidedatacopies: deal with upgrading and downgrading to that format
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43147
diff changeset
    16
from .revlogutils.flagutil import REVIDX_SIDEDATA
843da18386d5 sidedatacopies: deal with upgrading and downgrading to that format
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43147
diff changeset
    17
25924
cfc24c22454e copies: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25289
diff changeset
    18
from . import (
33886
252fb66ee5bb copies: use intersectmatchers() in non-merge p1 optimization
Yuya Nishihara <yuya@tcha.org>
parents: 33843
diff changeset
    19
    match as matchmod,
28000
d4247c306d82 copies: optimize forward copy detection logic for rebases
Durham Goode <durham@fb.com>
parents: 27876
diff changeset
    20
    node,
25924
cfc24c22454e copies: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25289
diff changeset
    21
    pathutil,
43106
d783f945a701 py3: finish porting iteritems() to pycompat and remove source transformer
Gregory Szorc <gregory.szorc@gmail.com>
parents: 43077
diff changeset
    22
    pycompat,
25924
cfc24c22454e copies: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25289
diff changeset
    23
    util,
cfc24c22454e copies: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25289
diff changeset
    24
)
43148
843da18386d5 sidedatacopies: deal with upgrading and downgrading to that format
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43147
diff changeset
    25
843da18386d5 sidedatacopies: deal with upgrading and downgrading to that format
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43147
diff changeset
    26
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 43022
diff changeset
    27
from .utils import stringutil
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 43022
diff changeset
    28
25924
cfc24c22454e copies: use absolute_import
Gregory Szorc <gregory.szorc@gmail.com>
parents: 25289
diff changeset
    29
42593
11ceb1b8fd74 copies: inline _chainandfilter() to prepare for next patch
Martin von Zweigbergk <martinvonz@google.com>
parents: 42592
diff changeset
    30
def _filter(src, dst, t):
11ceb1b8fd74 copies: inline _chainandfilter() to prepare for next patch
Martin von Zweigbergk <martinvonz@google.com>
parents: 42592
diff changeset
    31
    """filters out invalid copies after chaining"""
42257
d1c2688eda80 copies: document cases in _chain()
Martin von Zweigbergk <martinvonz@google.com>
parents: 42256
diff changeset
    32
42593
11ceb1b8fd74 copies: inline _chainandfilter() to prepare for next patch
Martin von Zweigbergk <martinvonz@google.com>
parents: 42592
diff changeset
    33
    # When _chain()'ing copies in 'a' (from 'src' via some other commit 'mid')
11ceb1b8fd74 copies: inline _chainandfilter() to prepare for next patch
Martin von Zweigbergk <martinvonz@google.com>
parents: 42592
diff changeset
    34
    # with copies in 'b' (from 'mid' to 'dst'), we can get the different cases
11ceb1b8fd74 copies: inline _chainandfilter() to prepare for next patch
Martin von Zweigbergk <martinvonz@google.com>
parents: 42592
diff changeset
    35
    # in the following table (not including trivial cases). For example, case 2
11ceb1b8fd74 copies: inline _chainandfilter() to prepare for next patch
Martin von Zweigbergk <martinvonz@google.com>
parents: 42592
diff changeset
    36
    # is where a file existed in 'src' and remained under that name in 'mid' and
42257
d1c2688eda80 copies: document cases in _chain()
Martin von Zweigbergk <martinvonz@google.com>
parents: 42256
diff changeset
    37
    # then was renamed between 'mid' and 'dst'.
d1c2688eda80 copies: document cases in _chain()
Martin von Zweigbergk <martinvonz@google.com>
parents: 42256
diff changeset
    38
    #
d1c2688eda80 copies: document cases in _chain()
Martin von Zweigbergk <martinvonz@google.com>
parents: 42256
diff changeset
    39
    # case src mid dst result
d1c2688eda80 copies: document cases in _chain()
Martin von Zweigbergk <martinvonz@google.com>
parents: 42256
diff changeset
    40
    #   1   x   y   -    -
d1c2688eda80 copies: document cases in _chain()
Martin von Zweigbergk <martinvonz@google.com>
parents: 42256
diff changeset
    41
    #   2   x   y   y   x->y
d1c2688eda80 copies: document cases in _chain()
Martin von Zweigbergk <martinvonz@google.com>
parents: 42256
diff changeset
    42
    #   3   x   y   x    -
d1c2688eda80 copies: document cases in _chain()
Martin von Zweigbergk <martinvonz@google.com>
parents: 42256
diff changeset
    43
    #   4   x   y   z   x->z
d1c2688eda80 copies: document cases in _chain()
Martin von Zweigbergk <martinvonz@google.com>
parents: 42256
diff changeset
    44
    #   5   -   x   y    -
d1c2688eda80 copies: document cases in _chain()
Martin von Zweigbergk <martinvonz@google.com>
parents: 42256
diff changeset
    45
    #   6   x   x   y   x->y
42395
f3d06d37e194 copies: split up _chain() in naive chaining and filtering steps
Martin von Zweigbergk <martinvonz@google.com>
parents: 42366
diff changeset
    46
    #
f3d06d37e194 copies: split up _chain() in naive chaining and filtering steps
Martin von Zweigbergk <martinvonz@google.com>
parents: 42366
diff changeset
    47
    # _chain() takes care of chaining the copies in 'a' and 'b', but it
f3d06d37e194 copies: split up _chain() in naive chaining and filtering steps
Martin von Zweigbergk <martinvonz@google.com>
parents: 42366
diff changeset
    48
    # cannot tell the difference between cases 1 and 2, between 3 and 4, or
f3d06d37e194 copies: split up _chain() in naive chaining and filtering steps
Martin von Zweigbergk <martinvonz@google.com>
parents: 42366
diff changeset
    49
    # between 5 and 6, so it includes all cases in its result.
f3d06d37e194 copies: split up _chain() in naive chaining and filtering steps
Martin von Zweigbergk <martinvonz@google.com>
parents: 42366
diff changeset
    50
    # Cases 1, 3, and 5 are then removed by _filter().
42257
d1c2688eda80 copies: document cases in _chain()
Martin von Zweigbergk <martinvonz@google.com>
parents: 42256
diff changeset
    51
42395
f3d06d37e194 copies: split up _chain() in naive chaining and filtering steps
Martin von Zweigbergk <martinvonz@google.com>
parents: 42366
diff changeset
    52
    for k, v in list(t.items()):
f3d06d37e194 copies: split up _chain() in naive chaining and filtering steps
Martin von Zweigbergk <martinvonz@google.com>
parents: 42366
diff changeset
    53
        # remove copies from files that didn't exist
f3d06d37e194 copies: split up _chain() in naive chaining and filtering steps
Martin von Zweigbergk <martinvonz@google.com>
parents: 42366
diff changeset
    54
        if v not in src:
f3d06d37e194 copies: split up _chain() in naive chaining and filtering steps
Martin von Zweigbergk <martinvonz@google.com>
parents: 42366
diff changeset
    55
            del t[k]
f3d06d37e194 copies: split up _chain() in naive chaining and filtering steps
Martin von Zweigbergk <martinvonz@google.com>
parents: 42366
diff changeset
    56
        # remove criss-crossed copies
f3d06d37e194 copies: split up _chain() in naive chaining and filtering steps
Martin von Zweigbergk <martinvonz@google.com>
parents: 42366
diff changeset
    57
        elif k in src and v in dst:
f3d06d37e194 copies: split up _chain() in naive chaining and filtering steps
Martin von Zweigbergk <martinvonz@google.com>
parents: 42366
diff changeset
    58
            del t[k]
f3d06d37e194 copies: split up _chain() in naive chaining and filtering steps
Martin von Zweigbergk <martinvonz@google.com>
parents: 42366
diff changeset
    59
        # remove copies to files that were then removed
f3d06d37e194 copies: split up _chain() in naive chaining and filtering steps
Martin von Zweigbergk <martinvonz@google.com>
parents: 42366
diff changeset
    60
        elif k not in dst:
f3d06d37e194 copies: split up _chain() in naive chaining and filtering steps
Martin von Zweigbergk <martinvonz@google.com>
parents: 42366
diff changeset
    61
            del t[k]
f3d06d37e194 copies: split up _chain() in naive chaining and filtering steps
Martin von Zweigbergk <martinvonz@google.com>
parents: 42366
diff changeset
    62
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 43022
diff changeset
    63
43804
995066c41bb2 copies: expand `_chain` variable name to make the function easier to read
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43803
diff changeset
    64
def _chain(prefix, suffix):
995066c41bb2 copies: expand `_chain` variable name to make the function easier to read
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43803
diff changeset
    65
    """chain two sets of copies 'prefix' and 'suffix'"""
995066c41bb2 copies: expand `_chain` variable name to make the function easier to read
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43803
diff changeset
    66
    result = prefix.copy()
995066c41bb2 copies: expand `_chain` variable name to make the function easier to read
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43803
diff changeset
    67
    for key, value in pycompat.iteritems(suffix):
995066c41bb2 copies: expand `_chain` variable name to make the function easier to read
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43803
diff changeset
    68
        result[key] = prefix.get(value, value)
995066c41bb2 copies: expand `_chain` variable name to make the function easier to read
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43803
diff changeset
    69
    return result
15775
91eb4512edd0 copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents: 15774
diff changeset
    70
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 43022
diff changeset
    71
43199
069cbbb53cdf copies: drop the findlimit logic
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43198
diff changeset
    72
def _tracefile(fctx, am, basemf):
35428
9cf37d111acb copies: consistently use """ for docstrings
Martin von Zweigbergk <martinvonz@google.com>
parents: 35427
diff changeset
    73
    """return file context that is the ancestor of fctx present in ancestor
43198
c16fe77e340a pathcopies: give up any optimization based on `introrev`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43148
diff changeset
    74
    manifest am
c16fe77e340a pathcopies: give up any optimization based on `introrev`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43148
diff changeset
    75
c16fe77e340a pathcopies: give up any optimization based on `introrev`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43148
diff changeset
    76
    Note: we used to try and stop after a given limit, however checking if that
c16fe77e340a pathcopies: give up any optimization based on `introrev`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43148
diff changeset
    77
    limit is reached turned out to be very expensive. we are better off
c16fe77e340a pathcopies: give up any optimization based on `introrev`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43148
diff changeset
    78
    disabling that feature."""
15775
91eb4512edd0 copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents: 15774
diff changeset
    79
91eb4512edd0 copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents: 15774
diff changeset
    80
    for f in fctx.ancestors():
42554
4ebbd7c4a3c5 copies: return only path from _tracefile() since that's all caller needs
Martin von Zweigbergk <martinvonz@google.com>
parents: 42527
diff changeset
    81
        path = f.path()
4ebbd7c4a3c5 copies: return only path from _tracefile() since that's all caller needs
Martin von Zweigbergk <martinvonz@google.com>
parents: 42527
diff changeset
    82
        if am.get(path, None) == f.filenode():
4ebbd7c4a3c5 copies: return only path from _tracefile() since that's all caller needs
Martin von Zweigbergk <martinvonz@google.com>
parents: 42527
diff changeset
    83
            return path
42595
819712deac69 copies: follow copies across merge base without source file (issue6163)
Martin von Zweigbergk <martinvonz@google.com>
parents: 42594
diff changeset
    84
        if basemf and basemf.get(path, None) == f.filenode():
819712deac69 copies: follow copies across merge base without source file (issue6163)
Martin von Zweigbergk <martinvonz@google.com>
parents: 42594
diff changeset
    85
            return path
15775
91eb4512edd0 copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents: 15774
diff changeset
    86
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 43022
diff changeset
    87
41761
012f695546aa copies: respect narrowmatcher in "parent -> working dir" case
Martin von Zweigbergk <martinvonz@google.com>
parents: 41735
diff changeset
    88
def _dirstatecopies(repo, match=None):
012f695546aa copies: respect narrowmatcher in "parent -> working dir" case
Martin von Zweigbergk <martinvonz@google.com>
parents: 41735
diff changeset
    89
    ds = repo.dirstate
15775
91eb4512edd0 copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents: 15774
diff changeset
    90
    c = ds.copies().copy()
34355
1a5abc45e2fa py3: explicitly convert dict.keys() and dict.items() into a list
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34318
diff changeset
    91
    for k in list(c):
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
    92
        if ds[k] not in b'anm' or (match and not match(k)):
15775
91eb4512edd0 copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents: 15774
diff changeset
    93
            del c[k]
91eb4512edd0 copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents: 15774
diff changeset
    94
    return c
91eb4512edd0 copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents: 15774
diff changeset
    95
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 43022
diff changeset
    96
24782
4906dc0e038c copies: add matcher parameter to copy logic
Durham Goode <durham@fb.com>
parents: 24625
diff changeset
    97
def _computeforwardmissing(a, b, match=None):
24011
d7d08337b3f6 copy: move _forwardcopies file logic to a function
Durham Goode <durham@fb.com>
parents: 24010
diff changeset
    98
    """Computes which files are in b but not a.
d7d08337b3f6 copy: move _forwardcopies file logic to a function
Durham Goode <durham@fb.com>
parents: 24010
diff changeset
    99
    This is its own function so extensions can easily wrap this call to see what
d7d08337b3f6 copy: move _forwardcopies file logic to a function
Durham Goode <durham@fb.com>
parents: 24010
diff changeset
   100
    files _forwardcopies is about to process.
d7d08337b3f6 copy: move _forwardcopies file logic to a function
Durham Goode <durham@fb.com>
parents: 24010
diff changeset
   101
    """
24782
4906dc0e038c copies: add matcher parameter to copy logic
Durham Goode <durham@fb.com>
parents: 24625
diff changeset
   102
    ma = a.manifest()
4906dc0e038c copies: add matcher parameter to copy logic
Durham Goode <durham@fb.com>
parents: 24625
diff changeset
   103
    mb = b.manifest()
31266
5a909a8098a1 copies: remove use of manifest.matches
Durham Goode <durham@fb.com>
parents: 30586
diff changeset
   104
    return mb.filesnotin(ma, match=match)
24011
d7d08337b3f6 copy: move _forwardcopies file logic to a function
Durham Goode <durham@fb.com>
parents: 24010
diff changeset
   105
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 43022
diff changeset
   106
42115
27475ae67676 copies: extract function for deciding whether to use changeset-centric algos
Martin von Zweigbergk <martinvonz@google.com>
parents: 41941
diff changeset
   107
def usechangesetcentricalgo(repo):
27475ae67676 copies: extract function for deciding whether to use changeset-centric algos
Martin von Zweigbergk <martinvonz@google.com>
parents: 41941
diff changeset
   108
    """Checks if we should use changeset-centric copy algorithms"""
43146
0171483b082f sidedatacopies: read rename information from sidedata
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43117
diff changeset
   109
    if repo.filecopiesmode == b'changeset-sidedata':
0171483b082f sidedatacopies: read rename information from sidedata
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43117
diff changeset
   110
        return True
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
   111
    readfrom = repo.ui.config(b'experimental', b'copies.read-from')
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
   112
    changesetsource = (b'changeset-only', b'compatibility')
43022
f3bcae1e9e23 copies: expand the logic of usechangesetcentricalgo
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 42729
diff changeset
   113
    return readfrom in changesetsource
42115
27475ae67676 copies: extract function for deciding whether to use changeset-centric algos
Martin von Zweigbergk <martinvonz@google.com>
parents: 41941
diff changeset
   114
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 43022
diff changeset
   115
42595
819712deac69 copies: follow copies across merge base without source file (issue6163)
Martin von Zweigbergk <martinvonz@google.com>
parents: 42594
diff changeset
   116
def _committedforwardcopies(a, b, base, match):
35429
8801cdcea01f copies: extract method for getting non-wdir forward copies
Martin von Zweigbergk <martinvonz@google.com>
parents: 35428
diff changeset
   117
    """Like _forwardcopies(), but b.rev() cannot be None (working copy)"""
20294
243ea5ffdf31 diff: search beyond ancestor when detecting renames
Mads Kiilerich <madski@unity3d.com>
parents: 19178
diff changeset
   118
    # files might have to be traced back to the fctx parent of the last
243ea5ffdf31 diff: search beyond ancestor when detecting renames
Mads Kiilerich <madski@unity3d.com>
parents: 19178
diff changeset
   119
    # one-side-only changeset, but not further back than that
40058
25b2868206e2 copies: add a devel debug mode to trace what copy tracing does
Boris Feld <boris.feld@octobus.net>
parents: 39967
diff changeset
   120
    repo = a._repo
41765
49ad315b39ee copies: do copy tracing based on ctx.p[12]copies() if configured
Martin von Zweigbergk <martinvonz@google.com>
parents: 41763
diff changeset
   121
42115
27475ae67676 copies: extract function for deciding whether to use changeset-centric algos
Martin von Zweigbergk <martinvonz@google.com>
parents: 41941
diff changeset
   122
    if usechangesetcentricalgo(repo):
41765
49ad315b39ee copies: do copy tracing based on ctx.p[12]copies() if configured
Martin von Zweigbergk <martinvonz@google.com>
parents: 41763
diff changeset
   123
        return _changesetforwardcopies(a, b, match)
49ad315b39ee copies: do copy tracing based on ctx.p[12]copies() if configured
Martin von Zweigbergk <martinvonz@google.com>
parents: 41763
diff changeset
   124
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
   125
    debug = repo.ui.debugflag and repo.ui.configbool(b'devel', b'debug.copies')
40058
25b2868206e2 copies: add a devel debug mode to trace what copy tracing does
Boris Feld <boris.feld@octobus.net>
parents: 39967
diff changeset
   126
    dbg = repo.ui.debug
25b2868206e2 copies: add a devel debug mode to trace what copy tracing does
Boris Feld <boris.feld@octobus.net>
parents: 39967
diff changeset
   127
    if debug:
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
   128
        dbg(b'debug.copies:    looking into rename from %s to %s\n' % (a, b))
20294
243ea5ffdf31 diff: search beyond ancestor when detecting renames
Mads Kiilerich <madski@unity3d.com>
parents: 19178
diff changeset
   129
    am = a.manifest()
42595
819712deac69 copies: follow copies across merge base without source file (issue6163)
Martin von Zweigbergk <martinvonz@google.com>
parents: 42594
diff changeset
   130
    basemf = None if base is None else base.manifest()
20294
243ea5ffdf31 diff: search beyond ancestor when detecting renames
Mads Kiilerich <madski@unity3d.com>
parents: 19178
diff changeset
   131
15775
91eb4512edd0 copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents: 15774
diff changeset
   132
    # find where new files came from
91eb4512edd0 copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents: 15774
diff changeset
   133
    # we currently don't try to find where old files went, too expensive
91eb4512edd0 copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents: 15774
diff changeset
   134
    # this means we can miss a case like 'hg rm b; hg cp a b'
91eb4512edd0 copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents: 15774
diff changeset
   135
    cm = {}
28000
d4247c306d82 copies: optimize forward copy detection logic for rebases
Durham Goode <durham@fb.com>
parents: 27876
diff changeset
   136
d4247c306d82 copies: optimize forward copy detection logic for rebases
Durham Goode <durham@fb.com>
parents: 27876
diff changeset
   137
    # Computing the forward missing is quite expensive on large manifests, since
d4247c306d82 copies: optimize forward copy detection logic for rebases
Durham Goode <durham@fb.com>
parents: 27876
diff changeset
   138
    # it compares the entire manifests. We can optimize it in the common use
d4247c306d82 copies: optimize forward copy detection logic for rebases
Durham Goode <durham@fb.com>
parents: 27876
diff changeset
   139
    # case of computing what copies are in a commit versus its parent (like
d4247c306d82 copies: optimize forward copy detection logic for rebases
Durham Goode <durham@fb.com>
parents: 27876
diff changeset
   140
    # during a rebase or histedit). Note, we exclude merge commits from this
d4247c306d82 copies: optimize forward copy detection logic for rebases
Durham Goode <durham@fb.com>
parents: 27876
diff changeset
   141
    # optimization, since the ctx.files() for a merge commit is not correct for
d4247c306d82 copies: optimize forward copy detection logic for rebases
Durham Goode <durham@fb.com>
parents: 27876
diff changeset
   142
    # this comparison.
d4247c306d82 copies: optimize forward copy detection logic for rebases
Durham Goode <durham@fb.com>
parents: 27876
diff changeset
   143
    forwardmissingmatch = match
33886
252fb66ee5bb copies: use intersectmatchers() in non-merge p1 optimization
Yuya Nishihara <yuya@tcha.org>
parents: 33843
diff changeset
   144
    if b.p1() == a and b.p2().node() == node.nullid:
41941
a791623458ef copies: remove dependency on scmutil by directly using match.exact()
Martin von Zweigbergk <martinvonz@google.com>
parents: 41937
diff changeset
   145
        filesmatcher = matchmod.exact(b.files())
33886
252fb66ee5bb copies: use intersectmatchers() in non-merge p1 optimization
Yuya Nishihara <yuya@tcha.org>
parents: 33843
diff changeset
   146
        forwardmissingmatch = matchmod.intersectmatchers(match, filesmatcher)
28000
d4247c306d82 copies: optimize forward copy detection logic for rebases
Durham Goode <durham@fb.com>
parents: 27876
diff changeset
   147
    missing = _computeforwardmissing(a, b, match=forwardmissingmatch)
d4247c306d82 copies: optimize forward copy detection logic for rebases
Durham Goode <durham@fb.com>
parents: 27876
diff changeset
   148
23980
c1ce5442453f _adjustlinkrev: reuse ancestors set during rename detection (issue4514)
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 23139
diff changeset
   149
    ancestrycontext = a._repo.changelog.ancestors([b.rev()], inclusive=True)
40058
25b2868206e2 copies: add a devel debug mode to trace what copy tracing does
Boris Feld <boris.feld@octobus.net>
parents: 39967
diff changeset
   150
25b2868206e2 copies: add a devel debug mode to trace what copy tracing does
Boris Feld <boris.feld@octobus.net>
parents: 39967
diff changeset
   151
    if debug:
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
   152
        dbg(b'debug.copies:      missing files to search: %d\n' % len(missing))
40058
25b2868206e2 copies: add a devel debug mode to trace what copy tracing does
Boris Feld <boris.feld@octobus.net>
parents: 39967
diff changeset
   153
42243
390ec72b8ea4 copies: process files in deterministic order for stable tests
Martin von Zweigbergk <martinvonz@google.com>
parents: 42211
diff changeset
   154
    for f in sorted(missing):
40058
25b2868206e2 copies: add a devel debug mode to trace what copy tracing does
Boris Feld <boris.feld@octobus.net>
parents: 39967
diff changeset
   155
        if debug:
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
   156
            dbg(b'debug.copies:        tracing file: %s\n' % f)
23980
c1ce5442453f _adjustlinkrev: reuse ancestors set during rename detection (issue4514)
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 23139
diff changeset
   157
        fctx = b[f]
c1ce5442453f _adjustlinkrev: reuse ancestors set during rename detection (issue4514)
Pierre-Yves David <pierre-yves.david@fb.com>
parents: 23139
diff changeset
   158
        fctx._ancestrycontext = ancestrycontext
40058
25b2868206e2 copies: add a devel debug mode to trace what copy tracing does
Boris Feld <boris.feld@octobus.net>
parents: 39967
diff changeset
   159
40059
cf01616f8d96 copies: add time information to the debug information
Boris Feld <boris.feld@octobus.net>
parents: 40058
diff changeset
   160
        if debug:
cf01616f8d96 copies: add time information to the debug information
Boris Feld <boris.feld@octobus.net>
parents: 40058
diff changeset
   161
            start = util.timer()
43199
069cbbb53cdf copies: drop the findlimit logic
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43198
diff changeset
   162
        opath = _tracefile(fctx, am, basemf)
42554
4ebbd7c4a3c5 copies: return only path from _tracefile() since that's all caller needs
Martin von Zweigbergk <martinvonz@google.com>
parents: 42527
diff changeset
   163
        if opath:
40058
25b2868206e2 copies: add a devel debug mode to trace what copy tracing does
Boris Feld <boris.feld@octobus.net>
parents: 39967
diff changeset
   164
            if debug:
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
   165
                dbg(b'debug.copies:          rename of: %s\n' % opath)
42554
4ebbd7c4a3c5 copies: return only path from _tracefile() since that's all caller needs
Martin von Zweigbergk <martinvonz@google.com>
parents: 42527
diff changeset
   166
            cm[f] = opath
40059
cf01616f8d96 copies: add time information to the debug information
Boris Feld <boris.feld@octobus.net>
parents: 40058
diff changeset
   167
        if debug:
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 43022
diff changeset
   168
            dbg(
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
   169
                b'debug.copies:          time: %f seconds\n'
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 43022
diff changeset
   170
                % (util.timer() - start)
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 43022
diff changeset
   171
            )
35429
8801cdcea01f copies: extract method for getting non-wdir forward copies
Martin von Zweigbergk <martinvonz@google.com>
parents: 35428
diff changeset
   172
    return cm
8801cdcea01f copies: extract method for getting non-wdir forward copies
Martin von Zweigbergk <martinvonz@google.com>
parents: 35428
diff changeset
   173
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 43022
diff changeset
   174
43255
b8d60845fa5d copies: extract data extraction into a `revinfo` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43254
diff changeset
   175
def _revinfogetter(repo):
b8d60845fa5d copies: extract data extraction into a `revinfo` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43254
diff changeset
   176
    """return a function that return multiple data given a <rev>"i
b8d60845fa5d copies: extract data extraction into a `revinfo` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43254
diff changeset
   177
b8d60845fa5d copies: extract data extraction into a `revinfo` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43254
diff changeset
   178
    * p1: revision number of first parent
b8d60845fa5d copies: extract data extraction into a `revinfo` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43254
diff changeset
   179
    * p2: revision number of first parent
b8d60845fa5d copies: extract data extraction into a `revinfo` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43254
diff changeset
   180
    * p1copies: mapping of copies from p1
b8d60845fa5d copies: extract data extraction into a `revinfo` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43254
diff changeset
   181
    * p2copies: mapping of copies from p2
b8d60845fa5d copies: extract data extraction into a `revinfo` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43254
diff changeset
   182
    * removed: a list of removed files
44858
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   183
    * ismerged: a callback to know if file was merged in that revision
43255
b8d60845fa5d copies: extract data extraction into a `revinfo` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43254
diff changeset
   184
    """
b8d60845fa5d copies: extract data extraction into a `revinfo` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43254
diff changeset
   185
    cl = repo.changelog
b8d60845fa5d copies: extract data extraction into a `revinfo` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43254
diff changeset
   186
    parents = cl.parentrevs
b8d60845fa5d copies: extract data extraction into a `revinfo` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43254
diff changeset
   187
44858
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   188
    def get_ismerged(rev):
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   189
        ctx = repo[rev]
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   190
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   191
        def ismerged(path):
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   192
            if path not in ctx.files():
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   193
                return False
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   194
            fctx = ctx[path]
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   195
            parents = fctx._filelog.parents(fctx._filenode)
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   196
            nb_parents = 0
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   197
            for n in parents:
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   198
                if n != node.nullid:
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   199
                    nb_parents += 1
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   200
            return nb_parents >= 2
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   201
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   202
        return ismerged
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   203
43257
675c776fbcd1 sidedatacopies: directly fetch copies information from sidedata
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43256
diff changeset
   204
    if repo.filecopiesmode == b'changeset-sidedata':
675c776fbcd1 sidedatacopies: directly fetch copies information from sidedata
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43256
diff changeset
   205
        changelogrevision = cl.changelogrevision
43297
8a2925265402 sidedatacopies: fast path data fetching if revision has no sidedata
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43257
diff changeset
   206
        flags = cl.flags
43257
675c776fbcd1 sidedatacopies: directly fetch copies information from sidedata
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43256
diff changeset
   207
43301
90213d027154 sidedatacopies: only fetch information once for merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43300
diff changeset
   208
        # A small cache to avoid doing the work twice for merges
90213d027154 sidedatacopies: only fetch information once for merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43300
diff changeset
   209
        #
90213d027154 sidedatacopies: only fetch information once for merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43300
diff changeset
   210
        # In the vast majority of cases, if we ask information for a revision
90213d027154 sidedatacopies: only fetch information once for merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43300
diff changeset
   211
        # about 1 parent, we'll later ask it for the other. So it make sense to
90213d027154 sidedatacopies: only fetch information once for merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43300
diff changeset
   212
        # keep the information around when reaching the first parent of a merge
90213d027154 sidedatacopies: only fetch information once for merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43300
diff changeset
   213
        # and dropping it after it was provided for the second parents.
90213d027154 sidedatacopies: only fetch information once for merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43300
diff changeset
   214
        #
90213d027154 sidedatacopies: only fetch information once for merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43300
diff changeset
   215
        # It exists cases were only one parent of the merge will be walked. It
90213d027154 sidedatacopies: only fetch information once for merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43300
diff changeset
   216
        # happens when the "destination" the copy tracing is descendant from a
90213d027154 sidedatacopies: only fetch information once for merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43300
diff changeset
   217
        # new root, not common with the "source". In that case, we will only walk
90213d027154 sidedatacopies: only fetch information once for merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43300
diff changeset
   218
        # through merge parents that are descendant of changesets common
90213d027154 sidedatacopies: only fetch information once for merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43300
diff changeset
   219
        # between "source" and "destination".
90213d027154 sidedatacopies: only fetch information once for merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43300
diff changeset
   220
        #
90213d027154 sidedatacopies: only fetch information once for merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43300
diff changeset
   221
        # With the current case implementation if such changesets have a copy
90213d027154 sidedatacopies: only fetch information once for merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43300
diff changeset
   222
        # information, we'll keep them in memory until the end of
90213d027154 sidedatacopies: only fetch information once for merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43300
diff changeset
   223
        # _changesetforwardcopies. We don't expect the case to be frequent
90213d027154 sidedatacopies: only fetch information once for merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43300
diff changeset
   224
        # enough to matters.
90213d027154 sidedatacopies: only fetch information once for merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43300
diff changeset
   225
        #
90213d027154 sidedatacopies: only fetch information once for merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43300
diff changeset
   226
        # In addition, it would be possible to reach pathological case, were
90213d027154 sidedatacopies: only fetch information once for merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43300
diff changeset
   227
        # many first parent are met before any second parent is reached. In
90213d027154 sidedatacopies: only fetch information once for merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43300
diff changeset
   228
        # that case the cache could grow. If this even become an issue one can
90213d027154 sidedatacopies: only fetch information once for merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43300
diff changeset
   229
        # safely introduce a maximum cache size. This would trade extra CPU/IO
90213d027154 sidedatacopies: only fetch information once for merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43300
diff changeset
   230
        # time to save memory.
90213d027154 sidedatacopies: only fetch information once for merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43300
diff changeset
   231
        merge_caches = {}
90213d027154 sidedatacopies: only fetch information once for merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43300
diff changeset
   232
43257
675c776fbcd1 sidedatacopies: directly fetch copies information from sidedata
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43256
diff changeset
   233
        def revinfo(rev):
675c776fbcd1 sidedatacopies: directly fetch copies information from sidedata
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43256
diff changeset
   234
            p1, p2 = parents(rev)
44858
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   235
            value = None
43297
8a2925265402 sidedatacopies: fast path data fetching if revision has no sidedata
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43257
diff changeset
   236
            if flags(rev) & REVIDX_SIDEDATA:
43301
90213d027154 sidedatacopies: only fetch information once for merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43300
diff changeset
   237
                e = merge_caches.pop(rev, None)
90213d027154 sidedatacopies: only fetch information once for merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43300
diff changeset
   238
                if e is not None:
90213d027154 sidedatacopies: only fetch information once for merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43300
diff changeset
   239
                    return e
43297
8a2925265402 sidedatacopies: fast path data fetching if revision has no sidedata
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43257
diff changeset
   240
                c = changelogrevision(rev)
8a2925265402 sidedatacopies: fast path data fetching if revision has no sidedata
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43257
diff changeset
   241
                p1copies = c.p1copies
8a2925265402 sidedatacopies: fast path data fetching if revision has no sidedata
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43257
diff changeset
   242
                p2copies = c.p2copies
8a2925265402 sidedatacopies: fast path data fetching if revision has no sidedata
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43257
diff changeset
   243
                removed = c.filesremoved
43301
90213d027154 sidedatacopies: only fetch information once for merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43300
diff changeset
   244
                if p1 != node.nullrev and p2 != node.nullrev:
90213d027154 sidedatacopies: only fetch information once for merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43300
diff changeset
   245
                    # XXX some case we over cache, IGNORE
44858
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   246
                    value = merge_caches[rev] = (
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   247
                        p1,
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   248
                        p2,
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   249
                        p1copies,
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   250
                        p2copies,
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   251
                        removed,
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   252
                        get_ismerged(rev),
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   253
                    )
43297
8a2925265402 sidedatacopies: fast path data fetching if revision has no sidedata
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43257
diff changeset
   254
            else:
8a2925265402 sidedatacopies: fast path data fetching if revision has no sidedata
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43257
diff changeset
   255
                p1copies = {}
8a2925265402 sidedatacopies: fast path data fetching if revision has no sidedata
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43257
diff changeset
   256
                p2copies = {}
43802
79750d781928 copies: return consistent type from revinfo
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43302
diff changeset
   257
                removed = []
44858
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   258
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   259
            if value is None:
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   260
                value = (p1, p2, p1copies, p2copies, removed, get_ismerged(rev))
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   261
            return value
43257
675c776fbcd1 sidedatacopies: directly fetch copies information from sidedata
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43256
diff changeset
   262
675c776fbcd1 sidedatacopies: directly fetch copies information from sidedata
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43256
diff changeset
   263
    else:
675c776fbcd1 sidedatacopies: directly fetch copies information from sidedata
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43256
diff changeset
   264
675c776fbcd1 sidedatacopies: directly fetch copies information from sidedata
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43256
diff changeset
   265
        def revinfo(rev):
675c776fbcd1 sidedatacopies: directly fetch copies information from sidedata
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43256
diff changeset
   266
            p1, p2 = parents(rev)
675c776fbcd1 sidedatacopies: directly fetch copies information from sidedata
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43256
diff changeset
   267
            ctx = repo[rev]
675c776fbcd1 sidedatacopies: directly fetch copies information from sidedata
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43256
diff changeset
   268
            p1copies, p2copies = ctx._copies
675c776fbcd1 sidedatacopies: directly fetch copies information from sidedata
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43256
diff changeset
   269
            removed = ctx.filesremoved()
44858
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   270
            return p1, p2, p1copies, p2copies, removed, get_ismerged(rev)
43255
b8d60845fa5d copies: extract data extraction into a `revinfo` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43254
diff changeset
   271
b8d60845fa5d copies: extract data extraction into a `revinfo` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43254
diff changeset
   272
    return revinfo
b8d60845fa5d copies: extract data extraction into a `revinfo` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43254
diff changeset
   273
b8d60845fa5d copies: extract data extraction into a `revinfo` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43254
diff changeset
   274
41765
49ad315b39ee copies: do copy tracing based on ctx.p[12]copies() if configured
Martin von Zweigbergk <martinvonz@google.com>
parents: 41763
diff changeset
   275
def _changesetforwardcopies(a, b, match):
42645
8c5a36805d5d copies: fix crash on in changeset-centric tracing from commit to itself
Martin von Zweigbergk <martinvonz@google.com>
parents: 42595
diff changeset
   276
    if a.rev() in (node.nullrev, b.rev()):
41765
49ad315b39ee copies: do copy tracing based on ctx.p[12]copies() if configured
Martin von Zweigbergk <martinvonz@google.com>
parents: 41763
diff changeset
   277
        return {}
49ad315b39ee copies: do copy tracing based on ctx.p[12]copies() if configured
Martin von Zweigbergk <martinvonz@google.com>
parents: 41763
diff changeset
   278
43256
00de32aa834e copies: use an unfiltered repository for the changeset centric algorithm
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43255
diff changeset
   279
    repo = a.repo().unfiltered()
41765
49ad315b39ee copies: do copy tracing based on ctx.p[12]copies() if configured
Martin von Zweigbergk <martinvonz@google.com>
parents: 41763
diff changeset
   280
    children = {}
43255
b8d60845fa5d copies: extract data extraction into a `revinfo` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43254
diff changeset
   281
    revinfo = _revinfogetter(repo)
b8d60845fa5d copies: extract data extraction into a `revinfo` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43254
diff changeset
   282
41765
49ad315b39ee copies: do copy tracing based on ctx.p[12]copies() if configured
Martin von Zweigbergk <martinvonz@google.com>
parents: 41763
diff changeset
   283
    cl = repo.changelog
44858
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   284
    isancestor = cl.isancestorrev  # XXX we should had chaching to this.
41765
49ad315b39ee copies: do copy tracing based on ctx.p[12]copies() if configured
Martin von Zweigbergk <martinvonz@google.com>
parents: 41763
diff changeset
   285
    missingrevs = cl.findmissingrevs(common=[a.rev()], heads=[b.rev()])
43299
83bb1e89ab9b copies: compute the exact set of revision to walk
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43297
diff changeset
   286
    mrset = set(missingrevs)
83bb1e89ab9b copies: compute the exact set of revision to walk
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43297
diff changeset
   287
    roots = set()
41765
49ad315b39ee copies: do copy tracing based on ctx.p[12]copies() if configured
Martin von Zweigbergk <martinvonz@google.com>
parents: 41763
diff changeset
   288
    for r in missingrevs:
49ad315b39ee copies: do copy tracing based on ctx.p[12]copies() if configured
Martin von Zweigbergk <martinvonz@google.com>
parents: 41763
diff changeset
   289
        for p in cl.parentrevs(r):
49ad315b39ee copies: do copy tracing based on ctx.p[12]copies() if configured
Martin von Zweigbergk <martinvonz@google.com>
parents: 41763
diff changeset
   290
            if p == node.nullrev:
49ad315b39ee copies: do copy tracing based on ctx.p[12]copies() if configured
Martin von Zweigbergk <martinvonz@google.com>
parents: 41763
diff changeset
   291
                continue
49ad315b39ee copies: do copy tracing based on ctx.p[12]copies() if configured
Martin von Zweigbergk <martinvonz@google.com>
parents: 41763
diff changeset
   292
            if p not in children:
49ad315b39ee copies: do copy tracing based on ctx.p[12]copies() if configured
Martin von Zweigbergk <martinvonz@google.com>
parents: 41763
diff changeset
   293
                children[p] = [r]
49ad315b39ee copies: do copy tracing based on ctx.p[12]copies() if configured
Martin von Zweigbergk <martinvonz@google.com>
parents: 41763
diff changeset
   294
            else:
49ad315b39ee copies: do copy tracing based on ctx.p[12]copies() if configured
Martin von Zweigbergk <martinvonz@google.com>
parents: 41763
diff changeset
   295
                children[p].append(r)
43299
83bb1e89ab9b copies: compute the exact set of revision to walk
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43297
diff changeset
   296
            if p not in mrset:
83bb1e89ab9b copies: compute the exact set of revision to walk
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43297
diff changeset
   297
                roots.add(p)
83bb1e89ab9b copies: compute the exact set of revision to walk
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43297
diff changeset
   298
    if not roots:
83bb1e89ab9b copies: compute the exact set of revision to walk
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43297
diff changeset
   299
        # no common revision to track copies from
83bb1e89ab9b copies: compute the exact set of revision to walk
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43297
diff changeset
   300
        return {}
83bb1e89ab9b copies: compute the exact set of revision to walk
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43297
diff changeset
   301
    min_root = min(roots)
41765
49ad315b39ee copies: do copy tracing based on ctx.p[12]copies() if configured
Martin von Zweigbergk <martinvonz@google.com>
parents: 41763
diff changeset
   302
43299
83bb1e89ab9b copies: compute the exact set of revision to walk
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43297
diff changeset
   303
    from_head = set(
83bb1e89ab9b copies: compute the exact set of revision to walk
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43297
diff changeset
   304
        cl.reachableroots(min_root, [b.rev()], list(roots), includepath=True)
83bb1e89ab9b copies: compute the exact set of revision to walk
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43297
diff changeset
   305
    )
83bb1e89ab9b copies: compute the exact set of revision to walk
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43297
diff changeset
   306
83bb1e89ab9b copies: compute the exact set of revision to walk
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43297
diff changeset
   307
    iterrevs = set(from_head)
83bb1e89ab9b copies: compute the exact set of revision to walk
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43297
diff changeset
   308
    iterrevs &= mrset
83bb1e89ab9b copies: compute the exact set of revision to walk
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43297
diff changeset
   309
    iterrevs.update(roots)
83bb1e89ab9b copies: compute the exact set of revision to walk
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43297
diff changeset
   310
    iterrevs.remove(b.rev())
43806
421ea5772039 copies: split the combination of the copies mapping in its own function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43805
diff changeset
   311
    revs = sorted(iterrevs)
44858
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   312
    return _combinechangesetcopies(
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   313
        revs, children, b.rev(), revinfo, match, isancestor
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   314
    )
43806
421ea5772039 copies: split the combination of the copies mapping in its own function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43805
diff changeset
   315
421ea5772039 copies: split the combination of the copies mapping in its own function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43805
diff changeset
   316
44858
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   317
def _combinechangesetcopies(
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   318
    revs, children, targetrev, revinfo, match, isancestor
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   319
):
43806
421ea5772039 copies: split the combination of the copies mapping in its own function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43805
diff changeset
   320
    """combine the copies information for each item of iterrevs
421ea5772039 copies: split the combination of the copies mapping in its own function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43805
diff changeset
   321
421ea5772039 copies: split the combination of the copies mapping in its own function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43805
diff changeset
   322
    revs: sorted iterable of revision to visit
421ea5772039 copies: split the combination of the copies mapping in its own function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43805
diff changeset
   323
    children: a {parent: [children]} mapping.
421ea5772039 copies: split the combination of the copies mapping in its own function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43805
diff changeset
   324
    targetrev: the final copies destination revision (not in iterrevs)
421ea5772039 copies: split the combination of the copies mapping in its own function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43805
diff changeset
   325
    revinfo(rev): a function that return (p1, p2, p1copies, p2copies, removed)
421ea5772039 copies: split the combination of the copies mapping in its own function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43805
diff changeset
   326
    match: a matcher
421ea5772039 copies: split the combination of the copies mapping in its own function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43805
diff changeset
   327
421ea5772039 copies: split the combination of the copies mapping in its own function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43805
diff changeset
   328
    It returns the aggregated copies information for `targetrev`.
421ea5772039 copies: split the combination of the copies mapping in its own function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43805
diff changeset
   329
    """
43805
3b039e43a1e6 copies: do not initialize the dictionary with root in changeset copies
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43804
diff changeset
   330
    all_copies = {}
42503
c0b51449bf6b copies: avoid calling matcher if matcher.always()
Martin von Zweigbergk <martinvonz@google.com>
parents: 42502
diff changeset
   331
    alwaysmatch = match.always()
43806
421ea5772039 copies: split the combination of the copies mapping in its own function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43805
diff changeset
   332
    for r in revs:
43805
3b039e43a1e6 copies: do not initialize the dictionary with root in changeset copies
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43804
diff changeset
   333
        copies = all_copies.pop(r, None)
3b039e43a1e6 copies: do not initialize the dictionary with root in changeset copies
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43804
diff changeset
   334
        if copies is None:
3b039e43a1e6 copies: do not initialize the dictionary with root in changeset copies
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43804
diff changeset
   335
            # this is a root
3b039e43a1e6 copies: do not initialize the dictionary with root in changeset copies
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43804
diff changeset
   336
            copies = {}
42502
5ceb91136ebe copies: avoid unnecessary copying of copy dict
Martin von Zweigbergk <martinvonz@google.com>
parents: 42501
diff changeset
   337
        for i, c in enumerate(children[r]):
44858
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   338
            p1, p2, p1copies, p2copies, removed, ismerged = revinfo(c)
43254
181d28ba05da copies: avoid instancing more changectx to access parent revisions
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43253
diff changeset
   339
            if r == p1:
41765
49ad315b39ee copies: do copy tracing based on ctx.p[12]copies() if configured
Martin von Zweigbergk <martinvonz@google.com>
parents: 41763
diff changeset
   340
                parent = 1
43253
82dabad535d2 copies: get copies information directly from _copies
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43252
diff changeset
   341
                childcopies = p1copies
41765
49ad315b39ee copies: do copy tracing based on ctx.p[12]copies() if configured
Martin von Zweigbergk <martinvonz@google.com>
parents: 41763
diff changeset
   342
            else:
43254
181d28ba05da copies: avoid instancing more changectx to access parent revisions
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43253
diff changeset
   343
                assert r == p2
41765
49ad315b39ee copies: do copy tracing based on ctx.p[12]copies() if configured
Martin von Zweigbergk <martinvonz@google.com>
parents: 41763
diff changeset
   344
                parent = 2
43253
82dabad535d2 copies: get copies information directly from _copies
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43252
diff changeset
   345
                childcopies = p2copies
42503
c0b51449bf6b copies: avoid calling matcher if matcher.always()
Martin von Zweigbergk <martinvonz@google.com>
parents: 42502
diff changeset
   346
            if not alwaysmatch:
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 43022
diff changeset
   347
                childcopies = {
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 43022
diff changeset
   348
                    dst: src for dst, src in childcopies.items() if match(dst)
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 43022
diff changeset
   349
                }
43300
ffd04bc9f57d copies: move from a copy on branchpoint to a copy on write approach
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43299
diff changeset
   350
            newcopies = copies
42522
e7c55e24d6bf copies: avoid reusing the same variable for two different copy dicts
Martin von Zweigbergk <martinvonz@google.com>
parents: 42503
diff changeset
   351
            if childcopies:
44858
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   352
                newcopies = copies.copy()
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   353
                for dest, source in pycompat.iteritems(childcopies):
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   354
                    prev = copies.get(source)
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   355
                    if prev is not None and prev[1] is not None:
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   356
                        source = prev[1]
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   357
                    newcopies[dest] = (c, source)
43300
ffd04bc9f57d copies: move from a copy on branchpoint to a copy on write approach
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43299
diff changeset
   358
                assert newcopies is not copies
43255
b8d60845fa5d copies: extract data extraction into a `revinfo` function
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43254
diff changeset
   359
            for f in removed:
42522
e7c55e24d6bf copies: avoid reusing the same variable for two different copy dicts
Martin von Zweigbergk <martinvonz@google.com>
parents: 42503
diff changeset
   360
                if f in newcopies:
43300
ffd04bc9f57d copies: move from a copy on branchpoint to a copy on write approach
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43299
diff changeset
   361
                    if newcopies is copies:
ffd04bc9f57d copies: move from a copy on branchpoint to a copy on write approach
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43299
diff changeset
   362
                        # copy on write to avoid affecting potential other
ffd04bc9f57d copies: move from a copy on branchpoint to a copy on write approach
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43299
diff changeset
   363
                        # branches.  when there are no other branches, this
ffd04bc9f57d copies: move from a copy on branchpoint to a copy on write approach
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43299
diff changeset
   364
                        # could be avoided.
ffd04bc9f57d copies: move from a copy on branchpoint to a copy on write approach
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43299
diff changeset
   365
                        newcopies = copies.copy()
44858
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   366
                    newcopies[f] = (c, None)
43252
32187ae9eeb3 copies: simplify the handling of merges
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43231
diff changeset
   367
            othercopies = all_copies.get(c)
32187ae9eeb3 copies: simplify the handling of merges
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43231
diff changeset
   368
            if othercopies is None:
32187ae9eeb3 copies: simplify the handling of merges
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43231
diff changeset
   369
                all_copies[c] = newcopies
32187ae9eeb3 copies: simplify the handling of merges
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43231
diff changeset
   370
            else:
32187ae9eeb3 copies: simplify the handling of merges
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43231
diff changeset
   371
                # we are the second parent to work on c, we need to merge our
32187ae9eeb3 copies: simplify the handling of merges
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43231
diff changeset
   372
                # work with the other.
32187ae9eeb3 copies: simplify the handling of merges
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43231
diff changeset
   373
                #
32187ae9eeb3 copies: simplify the handling of merges
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43231
diff changeset
   374
                # In case of conflict, parent 1 take precedence over parent 2.
32187ae9eeb3 copies: simplify the handling of merges
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43231
diff changeset
   375
                # This is an arbitrary choice made anew when implementing
32187ae9eeb3 copies: simplify the handling of merges
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43231
diff changeset
   376
                # changeset based copies. It was made without regards with
32187ae9eeb3 copies: simplify the handling of merges
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43231
diff changeset
   377
                # potential filelog related behavior.
32187ae9eeb3 copies: simplify the handling of merges
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43231
diff changeset
   378
                if parent == 1:
44858
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   379
                    _merge_copies_dict(
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   380
                        othercopies, newcopies, isancestor, ismerged
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   381
                    )
43252
32187ae9eeb3 copies: simplify the handling of merges
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43231
diff changeset
   382
                else:
44858
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   383
                    _merge_copies_dict(
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   384
                        newcopies, othercopies, isancestor, ismerged
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   385
                    )
43252
32187ae9eeb3 copies: simplify the handling of merges
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 43231
diff changeset
   386
                    all_copies[c] = newcopies
44858
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   387
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   388
    final_copies = {}
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   389
    for dest, (tt, source) in all_copies[targetrev].items():
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   390
        if source is not None:
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   391
            final_copies[dest] = source
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   392
    return final_copies
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   393
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   394
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   395
def _merge_copies_dict(minor, major, isancestor, ismerged):
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   396
    """merge two copies-mapping together, minor and major
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   397
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   398
    In case of conflict, value from "major" will be picked.
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   399
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   400
    - `isancestors(low_rev, high_rev)`: callable return True if `low_rev` is an
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   401
                                        ancestors of `high_rev`,
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   402
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   403
    - `ismerged(path)`: callable return True if `path` have been merged in the
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   404
                        current revision,
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   405
    """
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   406
    for dest, value in major.items():
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   407
        other = minor.get(dest)
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   408
        if other is None:
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   409
            minor[dest] = value
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   410
        else:
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   411
            new_tt = value[0]
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   412
            other_tt = other[0]
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   413
            if value[1] == other[1]:
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   414
                continue
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   415
            # content from "major" wins, unless it is older
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   416
            # than the branch point or there is a merge
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   417
            if (
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   418
                new_tt == other_tt
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   419
                or not isancestor(new_tt, other_tt)
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   420
                or ismerged(dest)
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   421
            ):
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   422
                minor[dest] = value
41765
49ad315b39ee copies: do copy tracing based on ctx.p[12]copies() if configured
Martin von Zweigbergk <martinvonz@google.com>
parents: 41763
diff changeset
   423
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 43022
diff changeset
   424
42595
819712deac69 copies: follow copies across merge base without source file (issue6163)
Martin von Zweigbergk <martinvonz@google.com>
parents: 42594
diff changeset
   425
def _forwardcopies(a, b, base=None, match=None):
35429
8801cdcea01f copies: extract method for getting non-wdir forward copies
Martin von Zweigbergk <martinvonz@google.com>
parents: 35428
diff changeset
   426
    """find {dst@b: src@a} copy mapping where a is an ancestor of b"""
8801cdcea01f copies: extract method for getting non-wdir forward copies
Martin von Zweigbergk <martinvonz@google.com>
parents: 35428
diff changeset
   427
42595
819712deac69 copies: follow copies across merge base without source file (issue6163)
Martin von Zweigbergk <martinvonz@google.com>
parents: 42594
diff changeset
   428
    if base is None:
819712deac69 copies: follow copies across merge base without source file (issue6163)
Martin von Zweigbergk <martinvonz@google.com>
parents: 42594
diff changeset
   429
        base = a
40422
873f3682c8af narrow: make copies.pathcopies() filter with narrowspec again
Martin von Zweigbergk <martinvonz@google.com>
parents: 40077
diff changeset
   430
    match = a.repo().narrowmatch(match)
35429
8801cdcea01f copies: extract method for getting non-wdir forward copies
Martin von Zweigbergk <martinvonz@google.com>
parents: 35428
diff changeset
   431
    # check for working copy
8801cdcea01f copies: extract method for getting non-wdir forward copies
Martin von Zweigbergk <martinvonz@google.com>
parents: 35428
diff changeset
   432
    if b.rev() is None:
42595
819712deac69 copies: follow copies across merge base without source file (issue6163)
Martin von Zweigbergk <martinvonz@google.com>
parents: 42594
diff changeset
   433
        cm = _committedforwardcopies(a, b.p1(), base, match)
35430
e54f02ec6a05 copies: group wdir-handling in one place
Martin von Zweigbergk <martinvonz@google.com>
parents: 35429
diff changeset
   434
        # combine copies from dirstate if necessary
42593
11ceb1b8fd74 copies: inline _chainandfilter() to prepare for next patch
Martin von Zweigbergk <martinvonz@google.com>
parents: 42592
diff changeset
   435
        copies = _chain(cm, _dirstatecopies(b._repo, match))
42592
a48f6f18dc6d copies: remove most early returns from pathcopies() and _forwardcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 42591
diff changeset
   436
    else:
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 43022
diff changeset
   437
        copies = _committedforwardcopies(a, b, base, match)
42592
a48f6f18dc6d copies: remove most early returns from pathcopies() and _forwardcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 42591
diff changeset
   438
    return copies
15775
91eb4512edd0 copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents: 15774
diff changeset
   439
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 43022
diff changeset
   440
41762
3158cb74fbca copies: make _backwardrenames() filter out copies by destination
Martin von Zweigbergk <martinvonz@google.com>
parents: 41761
diff changeset
   441
def _backwardrenames(a, b, match):
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
   442
    if a._repo.ui.config(b'experimental', b'copytrace') == b'off':
26013
38f92d12357c copy: add flag for disabling copy tracing
Durham Goode <durham@fb.com>
parents: 25924
diff changeset
   443
        return {}
38f92d12357c copy: add flag for disabling copy tracing
Durham Goode <durham@fb.com>
parents: 25924
diff changeset
   444
18136
f23dea2b296e copies: do not track backward copies, only renames (issue3739)
Siddharth Agarwal <sid0@fb.com>
parents: 18135
diff changeset
   445
    # Even though we're not taking copies into account, 1:n rename situations
f23dea2b296e copies: do not track backward copies, only renames (issue3739)
Siddharth Agarwal <sid0@fb.com>
parents: 18135
diff changeset
   446
    # can still exist (e.g. hg cp a b; hg mv a c). In those cases we
f23dea2b296e copies: do not track backward copies, only renames (issue3739)
Siddharth Agarwal <sid0@fb.com>
parents: 18135
diff changeset
   447
    # arbitrarily pick one of the renames.
41762
3158cb74fbca copies: make _backwardrenames() filter out copies by destination
Martin von Zweigbergk <martinvonz@google.com>
parents: 41761
diff changeset
   448
    # We don't want to pass in "match" here, since that would filter
3158cb74fbca copies: make _backwardrenames() filter out copies by destination
Martin von Zweigbergk <martinvonz@google.com>
parents: 41761
diff changeset
   449
    # the destination by it. Since we're reversing the copies, we want
3158cb74fbca copies: make _backwardrenames() filter out copies by destination
Martin von Zweigbergk <martinvonz@google.com>
parents: 41761
diff changeset
   450
    # to filter the source instead.
15775
91eb4512edd0 copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents: 15774
diff changeset
   451
    f = _forwardcopies(b, a)
91eb4512edd0 copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents: 15774
diff changeset
   452
    r = {}
43106
d783f945a701 py3: finish porting iteritems() to pycompat and remove source transformer
Gregory Szorc <gregory.szorc@gmail.com>
parents: 43077
diff changeset
   453
    for k, v in sorted(pycompat.iteritems(f)):
41762
3158cb74fbca copies: make _backwardrenames() filter out copies by destination
Martin von Zweigbergk <martinvonz@google.com>
parents: 41761
diff changeset
   454
        if match and not match(v):
3158cb74fbca copies: make _backwardrenames() filter out copies by destination
Martin von Zweigbergk <martinvonz@google.com>
parents: 41761
diff changeset
   455
            continue
18136
f23dea2b296e copies: do not track backward copies, only renames (issue3739)
Siddharth Agarwal <sid0@fb.com>
parents: 18135
diff changeset
   456
        # remove copies
f23dea2b296e copies: do not track backward copies, only renames (issue3739)
Siddharth Agarwal <sid0@fb.com>
parents: 18135
diff changeset
   457
        if v in a:
f23dea2b296e copies: do not track backward copies, only renames (issue3739)
Siddharth Agarwal <sid0@fb.com>
parents: 18135
diff changeset
   458
            continue
15775
91eb4512edd0 copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents: 15774
diff changeset
   459
        r[v] = k
91eb4512edd0 copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents: 15774
diff changeset
   460
    return r
91eb4512edd0 copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents: 15774
diff changeset
   461
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 43022
diff changeset
   462
24782
4906dc0e038c copies: add matcher parameter to copy logic
Durham Goode <durham@fb.com>
parents: 24625
diff changeset
   463
def pathcopies(x, y, match=None):
35428
9cf37d111acb copies: consistently use """ for docstrings
Martin von Zweigbergk <martinvonz@google.com>
parents: 35427
diff changeset
   464
    """find {dst@y: src@x} copy mapping for directed compare"""
40058
25b2868206e2 copies: add a devel debug mode to trace what copy tracing does
Boris Feld <boris.feld@octobus.net>
parents: 39967
diff changeset
   465
    repo = x._repo
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
   466
    debug = repo.ui.debugflag and repo.ui.configbool(b'devel', b'debug.copies')
40058
25b2868206e2 copies: add a devel debug mode to trace what copy tracing does
Boris Feld <boris.feld@octobus.net>
parents: 39967
diff changeset
   467
    if debug:
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
   468
        repo.ui.debug(
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
   469
            b'debug.copies: searching copies from %s to %s\n' % (x, y)
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
   470
        )
15775
91eb4512edd0 copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents: 15774
diff changeset
   471
    if x == y or not x or not y:
91eb4512edd0 copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents: 15774
diff changeset
   472
        return {}
44323
30862e226339 copies: avoid filtering by short-circuit dirstate-only copies earlier
Martin von Zweigbergk <martinvonz@google.com>
parents: 44299
diff changeset
   473
    if y.rev() is None and x == y.p1():
30862e226339 copies: avoid filtering by short-circuit dirstate-only copies earlier
Martin von Zweigbergk <martinvonz@google.com>
parents: 44299
diff changeset
   474
        if debug:
30862e226339 copies: avoid filtering by short-circuit dirstate-only copies earlier
Martin von Zweigbergk <martinvonz@google.com>
parents: 44299
diff changeset
   475
            repo.ui.debug(b'debug.copies: search mode: dirstate\n')
30862e226339 copies: avoid filtering by short-circuit dirstate-only copies earlier
Martin von Zweigbergk <martinvonz@google.com>
parents: 44299
diff changeset
   476
        # short-circuit to avoid issues with merge states
30862e226339 copies: avoid filtering by short-circuit dirstate-only copies earlier
Martin von Zweigbergk <martinvonz@google.com>
parents: 44299
diff changeset
   477
        return _dirstatecopies(repo, match)
15775
91eb4512edd0 copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents: 15774
diff changeset
   478
    a = y.ancestor(x)
91eb4512edd0 copies: rewrite copy detection for non-merge users
Matt Mackall <mpm@selenic.com>
parents: 15774
diff changeset
   479
    if a == x:
40058
25b2868206e2 copies: add a devel debug mode to trace what copy tracing does
Boris Feld <boris.feld@octobus.net>
parents: 39967
diff changeset
   480
        if debug:
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
   481
            repo.ui.debug(b'debug.copies: search mode: forward\n')
42592
a48f6f18dc6d copies: remove most early returns from pathcopies() and _forwardcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 42591
diff changeset
   482
        copies = _forwardcopies(x, y, match=match)
a48f6f18dc6d copies: remove most early returns from pathcopies() and _forwardcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 42591
diff changeset
   483
    elif a == y:
40058
25b2868206e2 copies: add a devel debug mode to trace what copy tracing does
Boris Feld <boris.feld@octobus.net>
parents: 39967
diff changeset
   484
        if debug:
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
   485
            repo.ui.debug(b'debug.copies: search mode: backward\n')
42592
a48f6f18dc6d copies: remove most early returns from pathcopies() and _forwardcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 42591
diff changeset
   486
        copies = _backwardrenames(x, y, match=match)
a48f6f18dc6d copies: remove most early returns from pathcopies() and _forwardcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 42591
diff changeset
   487
    else:
a48f6f18dc6d copies: remove most early returns from pathcopies() and _forwardcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 42591
diff changeset
   488
        if debug:
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
   489
            repo.ui.debug(b'debug.copies: search mode: combined\n')
42595
819712deac69 copies: follow copies across merge base without source file (issue6163)
Martin von Zweigbergk <martinvonz@google.com>
parents: 42594
diff changeset
   490
        base = None
819712deac69 copies: follow copies across merge base without source file (issue6163)
Martin von Zweigbergk <martinvonz@google.com>
parents: 42594
diff changeset
   491
        if a.rev() != node.nullrev:
819712deac69 copies: follow copies across merge base without source file (issue6163)
Martin von Zweigbergk <martinvonz@google.com>
parents: 42594
diff changeset
   492
            base = x
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 43022
diff changeset
   493
        copies = _chain(
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 43022
diff changeset
   494
            _backwardrenames(x, a, match=match),
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 43022
diff changeset
   495
            _forwardcopies(a, y, base, match=match),
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 43022
diff changeset
   496
        )
42594
d013099c551b copies: filter invalid copies only at end of pathcopies() (issue6163)
Martin von Zweigbergk <martinvonz@google.com>
parents: 42593
diff changeset
   497
    _filter(x, y, copies)
42592
a48f6f18dc6d copies: remove most early returns from pathcopies() and _forwardcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 42591
diff changeset
   498
    return copies
15774
0bd17a4bed88 copies: split the copies api for "normal" and merge cases (API)
Matt Mackall <mpm@selenic.com>
parents: 14494
diff changeset
   499
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 43022
diff changeset
   500
30186
f7ed5af31242 mergecopies: rename 'ca' to 'base'
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 30185
diff changeset
   501
def mergecopies(repo, c1, c2, base):
6274
f3f383efbeae copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
   502
    """
42118
967c098eed33 copies: move comment about implementation of mergecopies() to end
Martin von Zweigbergk <martinvonz@google.com>
parents: 42115
diff changeset
   503
    Finds moves and copies between context c1 and c2 that are relevant for
34095
b4b196092cc3 copytrace: move the default copytracing algorithm in a new function
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34094
diff changeset
   504
    merging. 'base' will be used as the merge base.
b4b196092cc3 copytrace: move the default copytracing algorithm in a new function
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34094
diff changeset
   505
b4b196092cc3 copytrace: move the default copytracing algorithm in a new function
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34094
diff changeset
   506
    Copytracing is used in commands like rebase, merge, unshelve, etc to merge
b4b196092cc3 copytrace: move the default copytracing algorithm in a new function
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34094
diff changeset
   507
    files that were moved/ copied in one merge parent and modified in another.
b4b196092cc3 copytrace: move the default copytracing algorithm in a new function
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34094
diff changeset
   508
    For example:
33843
42ad7cc645a4 copies: add more details to the documentation of mergecopies()
Pulkit Goyal <7895pulkit@gmail.com>
parents: 32663
diff changeset
   509
42ad7cc645a4 copies: add more details to the documentation of mergecopies()
Pulkit Goyal <7895pulkit@gmail.com>
parents: 32663
diff changeset
   510
    o          ---> 4 another commit
42ad7cc645a4 copies: add more details to the documentation of mergecopies()
Pulkit Goyal <7895pulkit@gmail.com>
parents: 32663
diff changeset
   511
    |
42ad7cc645a4 copies: add more details to the documentation of mergecopies()
Pulkit Goyal <7895pulkit@gmail.com>
parents: 32663
diff changeset
   512
    |   o      ---> 3 commit that modifies a.txt
42ad7cc645a4 copies: add more details to the documentation of mergecopies()
Pulkit Goyal <7895pulkit@gmail.com>
parents: 32663
diff changeset
   513
    |  /
42ad7cc645a4 copies: add more details to the documentation of mergecopies()
Pulkit Goyal <7895pulkit@gmail.com>
parents: 32663
diff changeset
   514
    o /        ---> 2 commit that moves a.txt to b.txt
42ad7cc645a4 copies: add more details to the documentation of mergecopies()
Pulkit Goyal <7895pulkit@gmail.com>
parents: 32663
diff changeset
   515
    |/
42ad7cc645a4 copies: add more details to the documentation of mergecopies()
Pulkit Goyal <7895pulkit@gmail.com>
parents: 32663
diff changeset
   516
    o          ---> 1 merge base
42ad7cc645a4 copies: add more details to the documentation of mergecopies()
Pulkit Goyal <7895pulkit@gmail.com>
parents: 32663
diff changeset
   517
42ad7cc645a4 copies: add more details to the documentation of mergecopies()
Pulkit Goyal <7895pulkit@gmail.com>
parents: 32663
diff changeset
   518
    If we try to rebase revision 3 on revision 4, since there is no a.txt in
42ad7cc645a4 copies: add more details to the documentation of mergecopies()
Pulkit Goyal <7895pulkit@gmail.com>
parents: 32663
diff changeset
   519
    revision 4, and if user have copytrace disabled, we prints the following
42ad7cc645a4 copies: add more details to the documentation of mergecopies()
Pulkit Goyal <7895pulkit@gmail.com>
parents: 32663
diff changeset
   520
    message:
42ad7cc645a4 copies: add more details to the documentation of mergecopies()
Pulkit Goyal <7895pulkit@gmail.com>
parents: 32663
diff changeset
   521
42ad7cc645a4 copies: add more details to the documentation of mergecopies()
Pulkit Goyal <7895pulkit@gmail.com>
parents: 32663
diff changeset
   522
    ```other changed <file> which local deleted```
42ad7cc645a4 copies: add more details to the documentation of mergecopies()
Pulkit Goyal <7895pulkit@gmail.com>
parents: 32663
diff changeset
   523
44274
7f8bdee0034e copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 44272
diff changeset
   524
    Returns a tuple where:
16168
7bbabfe25321 copies: add docstring for mergecopies
Matt Mackall <mpm@selenic.com>
parents: 15994
diff changeset
   525
44274
7f8bdee0034e copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 44272
diff changeset
   526
    "branch_copies" an instance of branch_copies.
18134
6c35b53cd28b copies: separate moves via directory renames from explicit copies
Siddharth Agarwal <sid0@fb.com>
parents: 17055
diff changeset
   527
16168
7bbabfe25321 copies: add docstring for mergecopies
Matt Mackall <mpm@selenic.com>
parents: 15994
diff changeset
   528
    "diverge" is a mapping of source name -> list of destination names
7bbabfe25321 copies: add docstring for mergecopies
Matt Mackall <mpm@selenic.com>
parents: 15994
diff changeset
   529
    for divergent renames.
16794
98687cdddcb1 merge: warn about file deleted in one branch and renamed in other (issue3074)
Thomas Arendsen Hein <thomas@intevation.de>
parents: 16792
diff changeset
   530
42118
967c098eed33 copies: move comment about implementation of mergecopies() to end
Martin von Zweigbergk <martinvonz@google.com>
parents: 42115
diff changeset
   531
    This function calls different copytracing algorithms based on config.
6274
f3f383efbeae copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
   532
    """
f3f383efbeae copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
   533
    # avoid silly behavior for update from empty dir
6430
a6a66e812c34 copies: teach symmetric difference about working revisions
Matt Mackall <mpm@selenic.com>
parents: 6429
diff changeset
   534
    if not c1 or not c2 or c1 == c2:
44275
fa9ad1da2e77 merge: start using the per-side copy dicts
Martin von Zweigbergk <martinvonz@google.com>
parents: 44274
diff changeset
   535
        return branch_copies(), branch_copies(), {}
6274
f3f383efbeae copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
   536
41761
012f695546aa copies: respect narrowmatcher in "parent -> working dir" case
Martin von Zweigbergk <martinvonz@google.com>
parents: 41735
diff changeset
   537
    narrowmatch = c1.repo().narrowmatch()
012f695546aa copies: respect narrowmatcher in "parent -> working dir" case
Martin von Zweigbergk <martinvonz@google.com>
parents: 41735
diff changeset
   538
6646
9eb274d773d9 copies: teach copies about dirstate.copies
Matt Mackall <mpm@selenic.com>
parents: 6431
diff changeset
   539
    # avoid silly behavior for parent -> working dir
13878
a8d13ee0ce68 misc: replace .parents()[0] with p1()
Matt Mackall <mpm@selenic.com>
parents: 12683
diff changeset
   540
    if c2.node() is None and c1.node() == repo.dirstate.p1():
44275
fa9ad1da2e77 merge: start using the per-side copy dicts
Martin von Zweigbergk <martinvonz@google.com>
parents: 44274
diff changeset
   541
        return (
fa9ad1da2e77 merge: start using the per-side copy dicts
Martin von Zweigbergk <martinvonz@google.com>
parents: 44274
diff changeset
   542
            branch_copies(_dirstatecopies(repo, narrowmatch)),
fa9ad1da2e77 merge: start using the per-side copy dicts
Martin von Zweigbergk <martinvonz@google.com>
parents: 44274
diff changeset
   543
            branch_copies(),
fa9ad1da2e77 merge: start using the per-side copy dicts
Martin von Zweigbergk <martinvonz@google.com>
parents: 44274
diff changeset
   544
            {},
fa9ad1da2e77 merge: start using the per-side copy dicts
Martin von Zweigbergk <martinvonz@google.com>
parents: 44274
diff changeset
   545
        )
6646
9eb274d773d9 copies: teach copies about dirstate.copies
Matt Mackall <mpm@selenic.com>
parents: 6431
diff changeset
   546
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
   547
    copytracing = repo.ui.config(b'experimental', b'copytrace')
42255
d8ca7b99fc51 copies: move check for experimental.copytrace==<falsy> earlier
Martin von Zweigbergk <martinvonz@google.com>
parents: 42254
diff changeset
   548
    if stringutil.parsebool(copytracing) is False:
d8ca7b99fc51 copies: move check for experimental.copytrace==<falsy> earlier
Martin von Zweigbergk <martinvonz@google.com>
parents: 42254
diff changeset
   549
        # stringutil.parsebool() returns None when it is unable to parse the
d8ca7b99fc51 copies: move check for experimental.copytrace==<falsy> earlier
Martin von Zweigbergk <martinvonz@google.com>
parents: 42254
diff changeset
   550
        # value, so we should rely on making sure copytracing is on such cases
44275
fa9ad1da2e77 merge: start using the per-side copy dicts
Martin von Zweigbergk <martinvonz@google.com>
parents: 44274
diff changeset
   551
        return branch_copies(), branch_copies(), {}
34095
b4b196092cc3 copytrace: move the default copytracing algorithm in a new function
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34094
diff changeset
   552
42256
a6be3af3a397 copies: ignore heuristics copytracing when using changeset-centric algos
Martin von Zweigbergk <martinvonz@google.com>
parents: 42255
diff changeset
   553
    if usechangesetcentricalgo(repo):
a6be3af3a397 copies: ignore heuristics copytracing when using changeset-centric algos
Martin von Zweigbergk <martinvonz@google.com>
parents: 42255
diff changeset
   554
        # The heuristics don't make sense when we need changeset-centric algos
a6be3af3a397 copies: ignore heuristics copytracing when using changeset-centric algos
Martin von Zweigbergk <martinvonz@google.com>
parents: 42255
diff changeset
   555
        return _fullcopytracing(repo, c1, c2, base)
a6be3af3a397 copies: ignore heuristics copytracing when using changeset-centric algos
Martin von Zweigbergk <martinvonz@google.com>
parents: 42255
diff changeset
   556
26013
38f92d12357c copy: add flag for disabling copy tracing
Durham Goode <durham@fb.com>
parents: 25924
diff changeset
   557
    # Copy trace disabling is explicitly below the node == p1 logic above
38f92d12357c copy: add flag for disabling copy tracing
Durham Goode <durham@fb.com>
parents: 25924
diff changeset
   558
    # because the logic above is required for a simple copy to be kept across a
38f92d12357c copy: add flag for disabling copy tracing
Durham Goode <durham@fb.com>
parents: 25924
diff changeset
   559
    # rebase.
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
   560
    if copytracing == b'heuristics':
34367
d00910b286cd copytrace: use ctx.mutable() instead of adhoc constant of non-public phases
Yuya Nishihara <yuya@tcha.org>
parents: 34355
diff changeset
   561
        # Do full copytracing if only non-public revisions are involved as
d00910b286cd copytrace: use ctx.mutable() instead of adhoc constant of non-public phases
Yuya Nishihara <yuya@tcha.org>
parents: 34355
diff changeset
   562
        # that will be fast enough and will also cover the copies which could
d00910b286cd copytrace: use ctx.mutable() instead of adhoc constant of non-public phases
Yuya Nishihara <yuya@tcha.org>
parents: 34355
diff changeset
   563
        # be missed by heuristics
34318
1826d695ad58 copytrace: add a a new config to limit the number of drafts in heuristics
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34295
diff changeset
   564
        if _isfullcopytraceable(repo, c1, base):
34295
fc3b8483c6cb copytrace: use the full copytracing method if only drafts are involved
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34191
diff changeset
   565
            return _fullcopytracing(repo, c1, c2, base)
34191
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34095
diff changeset
   566
        return _heuristicscopytracing(repo, c1, c2, base)
34095
b4b196092cc3 copytrace: move the default copytracing algorithm in a new function
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34094
diff changeset
   567
    else:
b4b196092cc3 copytrace: move the default copytracing algorithm in a new function
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34094
diff changeset
   568
        return _fullcopytracing(repo, c1, c2, base)
26013
38f92d12357c copy: add flag for disabling copy tracing
Durham Goode <durham@fb.com>
parents: 25924
diff changeset
   569
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 43022
diff changeset
   570
34318
1826d695ad58 copytrace: add a a new config to limit the number of drafts in heuristics
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34295
diff changeset
   571
def _isfullcopytraceable(repo, c1, base):
34367
d00910b286cd copytrace: use ctx.mutable() instead of adhoc constant of non-public phases
Yuya Nishihara <yuya@tcha.org>
parents: 34355
diff changeset
   572
    """ Checks that if base, source and destination are all no-public branches,
d00910b286cd copytrace: use ctx.mutable() instead of adhoc constant of non-public phases
Yuya Nishihara <yuya@tcha.org>
parents: 34355
diff changeset
   573
    if yes let's use the full copytrace algorithm for increased capabilities
d00910b286cd copytrace: use ctx.mutable() instead of adhoc constant of non-public phases
Yuya Nishihara <yuya@tcha.org>
parents: 34355
diff changeset
   574
    since it will be fast enough.
34516
e79b3611223b copies: add docs for config `experimental.copytrace.sourcecommitlimit`
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34367
diff changeset
   575
e79b3611223b copies: add docs for config `experimental.copytrace.sourcecommitlimit`
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34367
diff changeset
   576
    `experimental.copytrace.sourcecommitlimit` can be used to set a limit for
e79b3611223b copies: add docs for config `experimental.copytrace.sourcecommitlimit`
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34367
diff changeset
   577
    number of changesets from c1 to base such that if number of changesets are
e79b3611223b copies: add docs for config `experimental.copytrace.sourcecommitlimit`
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34367
diff changeset
   578
    more than the limit, full copytracing algorithm won't be used.
34295
fc3b8483c6cb copytrace: use the full copytracing method if only drafts are involved
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34191
diff changeset
   579
    """
34318
1826d695ad58 copytrace: add a a new config to limit the number of drafts in heuristics
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34295
diff changeset
   580
    if c1.rev() is None:
1826d695ad58 copytrace: add a a new config to limit the number of drafts in heuristics
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34295
diff changeset
   581
        c1 = c1.p1()
34367
d00910b286cd copytrace: use ctx.mutable() instead of adhoc constant of non-public phases
Yuya Nishihara <yuya@tcha.org>
parents: 34355
diff changeset
   582
    if c1.mutable() and base.mutable():
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 43022
diff changeset
   583
        sourcecommitlimit = repo.ui.configint(
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
   584
            b'experimental', b'copytrace.sourcecommitlimit'
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 43022
diff changeset
   585
        )
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
   586
        commits = len(repo.revs(b'%d::%d', base.rev(), c1.rev()))
34318
1826d695ad58 copytrace: add a a new config to limit the number of drafts in heuristics
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34295
diff changeset
   587
        return commits < sourcecommitlimit
34295
fc3b8483c6cb copytrace: use the full copytracing method if only drafts are involved
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34191
diff changeset
   588
    return False
fc3b8483c6cb copytrace: use the full copytracing method if only drafts are involved
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34191
diff changeset
   589
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 43022
diff changeset
   590
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 43022
diff changeset
   591
def _checksinglesidecopies(
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 43022
diff changeset
   592
    src, dsts1, m1, m2, mb, c2, base, copy, renamedelete
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 43022
diff changeset
   593
):
42252
57203e0210f8 copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 42243
diff changeset
   594
    if src not in m2:
57203e0210f8 copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 42243
diff changeset
   595
        # deleted on side 2
57203e0210f8 copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 42243
diff changeset
   596
        if src not in m1:
57203e0210f8 copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 42243
diff changeset
   597
            # renamed on side 1, deleted on side 2
57203e0210f8 copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 42243
diff changeset
   598
            renamedelete[src] = dsts1
44284
d0c3eead515a copies: fix crash when copy source is not in graft base
Martin von Zweigbergk <martinvonz@google.com>
parents: 44275
diff changeset
   599
    elif src not in mb:
d0c3eead515a copies: fix crash when copy source is not in graft base
Martin von Zweigbergk <martinvonz@google.com>
parents: 44275
diff changeset
   600
        # Work around the "short-circuit to avoid issues with merge states"
d0c3eead515a copies: fix crash when copy source is not in graft base
Martin von Zweigbergk <martinvonz@google.com>
parents: 44275
diff changeset
   601
        # thing in pathcopies(): pathcopies(x, y) can return a copy where the
d0c3eead515a copies: fix crash when copy source is not in graft base
Martin von Zweigbergk <martinvonz@google.com>
parents: 44275
diff changeset
   602
        # destination doesn't exist in y.
d0c3eead515a copies: fix crash when copy source is not in graft base
Martin von Zweigbergk <martinvonz@google.com>
parents: 44275
diff changeset
   603
        pass
44788
d452acc8cce8 flags: account for flag change when tracking rename relevant to merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   604
    elif mb[src] != m2[src] and not _related(c2[src], base[src]):
d452acc8cce8 flags: account for flag change when tracking rename relevant to merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   605
        return
d452acc8cce8 flags: account for flag change when tracking rename relevant to merge
Pierre-Yves David <pierre-yves.david@octobus.net>
parents: 44323
diff changeset
   606
    elif mb[src] != m2[src] or mb.flags(src) != m2.flags(src):
42252
57203e0210f8 copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 42243
diff changeset
   607
        # modified on side 2
57203e0210f8 copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 42243
diff changeset
   608
        for dst in dsts1:
44299
b4057d001760 merge: when rename was made on both sides, use ancestor as merge base
Martin von Zweigbergk <martinvonz@google.com>
parents: 44284
diff changeset
   609
            copy[dst] = src
42252
57203e0210f8 copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 42243
diff changeset
   610
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 43022
diff changeset
   611
44274
7f8bdee0034e copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 44272
diff changeset
   612
class branch_copies(object):
7f8bdee0034e copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 44272
diff changeset
   613
    """Information about copies made on one side of a merge/graft.
7f8bdee0034e copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 44272
diff changeset
   614
7f8bdee0034e copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 44272
diff changeset
   615
    "copy" is a mapping from destination name -> source name,
7f8bdee0034e copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 44272
diff changeset
   616
    where source is in c1 and destination is in c2 or vice-versa.
7f8bdee0034e copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 44272
diff changeset
   617
7f8bdee0034e copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 44272
diff changeset
   618
    "movewithdir" is a mapping from source name -> destination name,
7f8bdee0034e copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 44272
diff changeset
   619
    where the file at source present in one context but not the other
7f8bdee0034e copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 44272
diff changeset
   620
    needs to be moved to destination by the merge process, because the
7f8bdee0034e copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 44272
diff changeset
   621
    other context moved the directory it is in.
7f8bdee0034e copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 44272
diff changeset
   622
7f8bdee0034e copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 44272
diff changeset
   623
    "renamedelete" is a mapping of source name -> list of destination
7f8bdee0034e copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 44272
diff changeset
   624
    names for files deleted in c1 that were renamed in c2 or vice-versa.
7f8bdee0034e copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 44272
diff changeset
   625
7f8bdee0034e copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 44272
diff changeset
   626
    "dirmove" is a mapping of detected source dir -> destination dir renames.
7f8bdee0034e copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 44272
diff changeset
   627
    This is needed for handling changes to new files previously grafted into
7f8bdee0034e copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 44272
diff changeset
   628
    renamed directories.
7f8bdee0034e copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 44272
diff changeset
   629
    """
7f8bdee0034e copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 44272
diff changeset
   630
7f8bdee0034e copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 44272
diff changeset
   631
    def __init__(
7f8bdee0034e copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 44272
diff changeset
   632
        self, copy=None, renamedelete=None, dirmove=None, movewithdir=None
7f8bdee0034e copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 44272
diff changeset
   633
    ):
7f8bdee0034e copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 44272
diff changeset
   634
        self.copy = {} if copy is None else copy
7f8bdee0034e copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 44272
diff changeset
   635
        self.renamedelete = {} if renamedelete is None else renamedelete
7f8bdee0034e copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 44272
diff changeset
   636
        self.dirmove = {} if dirmove is None else dirmove
7f8bdee0034e copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 44272
diff changeset
   637
        self.movewithdir = {} if movewithdir is None else movewithdir
7f8bdee0034e copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 44272
diff changeset
   638
45014
cfd06649a1b8 copies: implement __repr__ on branch_copies for debugging
Martin von Zweigbergk <martinvonz@google.com>
parents: 44981
diff changeset
   639
    def __repr__(self):
cfd06649a1b8 copies: implement __repr__ on branch_copies for debugging
Martin von Zweigbergk <martinvonz@google.com>
parents: 44981
diff changeset
   640
        return (
cfd06649a1b8 copies: implement __repr__ on branch_copies for debugging
Martin von Zweigbergk <martinvonz@google.com>
parents: 44981
diff changeset
   641
            '<branch_copies\n  copy=%r\n  renamedelete=%r\n  dirmove=%r\n  movewithdir=%r\n>'
cfd06649a1b8 copies: implement __repr__ on branch_copies for debugging
Martin von Zweigbergk <martinvonz@google.com>
parents: 44981
diff changeset
   642
            % (self.copy, self.renamedelete, self.dirmove, self.movewithdir,)
cfd06649a1b8 copies: implement __repr__ on branch_copies for debugging
Martin von Zweigbergk <martinvonz@google.com>
parents: 44981
diff changeset
   643
        )
cfd06649a1b8 copies: implement __repr__ on branch_copies for debugging
Martin von Zweigbergk <martinvonz@google.com>
parents: 44981
diff changeset
   644
44274
7f8bdee0034e copies: define a type to return from mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 44272
diff changeset
   645
34095
b4b196092cc3 copytrace: move the default copytracing algorithm in a new function
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34094
diff changeset
   646
def _fullcopytracing(repo, c1, c2, base):
b4b196092cc3 copytrace: move the default copytracing algorithm in a new function
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34094
diff changeset
   647
    """ The full copytracing algorithm which finds all the new files that were
b4b196092cc3 copytrace: move the default copytracing algorithm in a new function
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34094
diff changeset
   648
    added from merge base up to the top commit and for each file it checks if
b4b196092cc3 copytrace: move the default copytracing algorithm in a new function
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34094
diff changeset
   649
    this file was copied from another file.
b4b196092cc3 copytrace: move the default copytracing algorithm in a new function
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34094
diff changeset
   650
b4b196092cc3 copytrace: move the default copytracing algorithm in a new function
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34094
diff changeset
   651
    This is pretty slow when a lot of changesets are involved but will track all
b4b196092cc3 copytrace: move the default copytracing algorithm in a new function
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34094
diff changeset
   652
    the copies.
b4b196092cc3 copytrace: move the default copytracing algorithm in a new function
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34094
diff changeset
   653
    """
6274
f3f383efbeae copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
   654
    m1 = c1.manifest()
f3f383efbeae copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
   655
    m2 = c2.manifest()
30186
f7ed5af31242 mergecopies: rename 'ca' to 'base'
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 30185
diff changeset
   656
    mb = base.manifest()
6274
f3f383efbeae copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
   657
42252
57203e0210f8 copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 42243
diff changeset
   658
    copies1 = pathcopies(base, c1)
57203e0210f8 copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 42243
diff changeset
   659
    copies2 = pathcopies(base, c2)
57203e0210f8 copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 42243
diff changeset
   660
44242
baf3fe2977cc copies: move early return in mergecopies() earlier
Martin von Zweigbergk <martinvonz@google.com>
parents: 44093
diff changeset
   661
    if not (copies1 or copies2):
44275
fa9ad1da2e77 merge: start using the per-side copy dicts
Martin von Zweigbergk <martinvonz@google.com>
parents: 44274
diff changeset
   662
        return branch_copies(), branch_copies(), {}
44242
baf3fe2977cc copies: move early return in mergecopies() earlier
Martin von Zweigbergk <martinvonz@google.com>
parents: 44093
diff changeset
   663
42252
57203e0210f8 copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 42243
diff changeset
   664
    inversecopies1 = {}
57203e0210f8 copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 42243
diff changeset
   665
    inversecopies2 = {}
57203e0210f8 copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 42243
diff changeset
   666
    for dst, src in copies1.items():
57203e0210f8 copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 42243
diff changeset
   667
        inversecopies1.setdefault(src, []).append(dst)
57203e0210f8 copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 42243
diff changeset
   668
    for dst, src in copies2.items():
57203e0210f8 copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 42243
diff changeset
   669
        inversecopies2.setdefault(src, []).append(dst)
57203e0210f8 copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 42243
diff changeset
   670
44271
6ca9f45b32b0 copies: make mergecopies() distinguish between copies on each side
Martin von Zweigbergk <martinvonz@google.com>
parents: 44244
diff changeset
   671
    copy1 = {}
6ca9f45b32b0 copies: make mergecopies() distinguish between copies on each side
Martin von Zweigbergk <martinvonz@google.com>
parents: 44244
diff changeset
   672
    copy2 = {}
42252
57203e0210f8 copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 42243
diff changeset
   673
    diverge = {}
44271
6ca9f45b32b0 copies: make mergecopies() distinguish between copies on each side
Martin von Zweigbergk <martinvonz@google.com>
parents: 44244
diff changeset
   674
    renamedelete1 = {}
6ca9f45b32b0 copies: make mergecopies() distinguish between copies on each side
Martin von Zweigbergk <martinvonz@google.com>
parents: 44244
diff changeset
   675
    renamedelete2 = {}
42252
57203e0210f8 copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 42243
diff changeset
   676
    allsources = set(inversecopies1) | set(inversecopies2)
57203e0210f8 copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 42243
diff changeset
   677
    for src in allsources:
57203e0210f8 copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 42243
diff changeset
   678
        dsts1 = inversecopies1.get(src)
57203e0210f8 copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 42243
diff changeset
   679
        dsts2 = inversecopies2.get(src)
57203e0210f8 copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 42243
diff changeset
   680
        if dsts1 and dsts2:
57203e0210f8 copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 42243
diff changeset
   681
            # copied/renamed on both sides
57203e0210f8 copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 42243
diff changeset
   682
            if src not in m1 and src not in m2:
57203e0210f8 copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 42243
diff changeset
   683
                # renamed on both sides
57203e0210f8 copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 42243
diff changeset
   684
                dsts1 = set(dsts1)
57203e0210f8 copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 42243
diff changeset
   685
                dsts2 = set(dsts2)
57203e0210f8 copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 42243
diff changeset
   686
                # If there's some overlap in the rename destinations, we
57203e0210f8 copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 42243
diff changeset
   687
                # consider it not divergent. For example, if side 1 copies 'a'
57203e0210f8 copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 42243
diff changeset
   688
                # to 'b' and 'c' and deletes 'a', and side 2 copies 'a' to 'c'
57203e0210f8 copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 42243
diff changeset
   689
                # and 'd' and deletes 'a'.
57203e0210f8 copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 42243
diff changeset
   690
                if dsts1 & dsts2:
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 43022
diff changeset
   691
                    for dst in dsts1 & dsts2:
44271
6ca9f45b32b0 copies: make mergecopies() distinguish between copies on each side
Martin von Zweigbergk <martinvonz@google.com>
parents: 44244
diff changeset
   692
                        copy1[dst] = src
6ca9f45b32b0 copies: make mergecopies() distinguish between copies on each side
Martin von Zweigbergk <martinvonz@google.com>
parents: 44244
diff changeset
   693
                        copy2[dst] = src
42252
57203e0210f8 copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 42243
diff changeset
   694
                else:
57203e0210f8 copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 42243
diff changeset
   695
                    diverge[src] = sorted(dsts1 | dsts2)
57203e0210f8 copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 42243
diff changeset
   696
            elif src in m1 and src in m2:
57203e0210f8 copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 42243
diff changeset
   697
                # copied on both sides
57203e0210f8 copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 42243
diff changeset
   698
                dsts1 = set(dsts1)
57203e0210f8 copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 42243
diff changeset
   699
                dsts2 = set(dsts2)
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 43022
diff changeset
   700
                for dst in dsts1 & dsts2:
44271
6ca9f45b32b0 copies: make mergecopies() distinguish between copies on each side
Martin von Zweigbergk <martinvonz@google.com>
parents: 44244
diff changeset
   701
                    copy1[dst] = src
6ca9f45b32b0 copies: make mergecopies() distinguish between copies on each side
Martin von Zweigbergk <martinvonz@google.com>
parents: 44244
diff changeset
   702
                    copy2[dst] = src
42252
57203e0210f8 copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 42243
diff changeset
   703
            # TODO: Handle cases where it was renamed on one side and copied
57203e0210f8 copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 42243
diff changeset
   704
            # on the other side
57203e0210f8 copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 42243
diff changeset
   705
        elif dsts1:
57203e0210f8 copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 42243
diff changeset
   706
            # copied/renamed only on side 1
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 43022
diff changeset
   707
            _checksinglesidecopies(
44271
6ca9f45b32b0 copies: make mergecopies() distinguish between copies on each side
Martin von Zweigbergk <martinvonz@google.com>
parents: 44244
diff changeset
   708
                src, dsts1, m1, m2, mb, c2, base, copy1, renamedelete1
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 43022
diff changeset
   709
            )
42252
57203e0210f8 copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 42243
diff changeset
   710
        elif dsts2:
57203e0210f8 copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 42243
diff changeset
   711
            # copied/renamed only on side 2
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 43022
diff changeset
   712
            _checksinglesidecopies(
44271
6ca9f45b32b0 copies: make mergecopies() distinguish between copies on each side
Martin von Zweigbergk <martinvonz@google.com>
parents: 44244
diff changeset
   713
                src, dsts2, m2, m1, mb, c1, base, copy2, renamedelete2
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 43022
diff changeset
   714
            )
42252
57203e0210f8 copies: calculate mergecopies() based on pathcopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 42243
diff changeset
   715
26659
df66736a128e copies: group bothnew with other sets
Matt Mackall <mpm@selenic.com>
parents: 26658
diff changeset
   716
    # find interesting file sets from manifests
39967
707c3804e607 narrow: move copies overrides to core
Martin von Zweigbergk <martinvonz@google.com>
parents: 39946
diff changeset
   717
    addedinm1 = m1.filesnotin(mb, repo.narrowmatch())
707c3804e607 narrow: move copies overrides to core
Martin von Zweigbergk <martinvonz@google.com>
parents: 39946
diff changeset
   718
    addedinm2 = m2.filesnotin(mb, repo.narrowmatch())
42253
d69bc8ffbe6f copies: inline _computenonoverlap() in mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 42252
diff changeset
   719
    u1 = sorted(addedinm1 - addedinm2)
d69bc8ffbe6f copies: inline _computenonoverlap() in mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 42252
diff changeset
   720
    u2 = sorted(addedinm2 - addedinm1)
d69bc8ffbe6f copies: inline _computenonoverlap() in mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 42252
diff changeset
   721
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
   722
    header = b"  unmatched files in %s"
42253
d69bc8ffbe6f copies: inline _computenonoverlap() in mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 42252
diff changeset
   723
    if u1:
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
   724
        repo.ui.debug(b"%s:\n   %s\n" % (header % b'local', b"\n   ".join(u1)))
42253
d69bc8ffbe6f copies: inline _computenonoverlap() in mergecopies()
Martin von Zweigbergk <martinvonz@google.com>
parents: 42252
diff changeset
   725
    if u2:
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
   726
        repo.ui.debug(b"%s:\n   %s\n" % (header % b'other', b"\n   ".join(u2)))
6274
f3f383efbeae copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
   727
42208
85f5934016f9 copies: move early return for "no copies" case a little earlier
Martin von Zweigbergk <martinvonz@google.com>
parents: 42207
diff changeset
   728
    if repo.ui.debugflag:
44243
782e0d9c3b74 copies: avoid calculating debug-only stuff without --debug
Martin von Zweigbergk <martinvonz@google.com>
parents: 44242
diff changeset
   729
        renamedeleteset = set()
782e0d9c3b74 copies: avoid calculating debug-only stuff without --debug
Martin von Zweigbergk <martinvonz@google.com>
parents: 44242
diff changeset
   730
        divergeset = set()
782e0d9c3b74 copies: avoid calculating debug-only stuff without --debug
Martin von Zweigbergk <martinvonz@google.com>
parents: 44242
diff changeset
   731
        for dsts in diverge.values():
782e0d9c3b74 copies: avoid calculating debug-only stuff without --debug
Martin von Zweigbergk <martinvonz@google.com>
parents: 44242
diff changeset
   732
            divergeset.update(dsts)
44271
6ca9f45b32b0 copies: make mergecopies() distinguish between copies on each side
Martin von Zweigbergk <martinvonz@google.com>
parents: 44244
diff changeset
   733
        for dsts in renamedelete1.values():
6ca9f45b32b0 copies: make mergecopies() distinguish between copies on each side
Martin von Zweigbergk <martinvonz@google.com>
parents: 44244
diff changeset
   734
            renamedeleteset.update(dsts)
6ca9f45b32b0 copies: make mergecopies() distinguish between copies on each side
Martin von Zweigbergk <martinvonz@google.com>
parents: 44244
diff changeset
   735
        for dsts in renamedelete2.values():
44243
782e0d9c3b74 copies: avoid calculating debug-only stuff without --debug
Martin von Zweigbergk <martinvonz@google.com>
parents: 44242
diff changeset
   736
            renamedeleteset.update(dsts)
782e0d9c3b74 copies: avoid calculating debug-only stuff without --debug
Martin von Zweigbergk <martinvonz@google.com>
parents: 44242
diff changeset
   737
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 43022
diff changeset
   738
        repo.ui.debug(
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
   739
            b"  all copies found (* = to merge, ! = divergent, "
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
   740
            b"% = renamed and deleted):\n"
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 43022
diff changeset
   741
        )
44272
17e12938f8e7 copies: print debug information about copies per side/branch
Martin von Zweigbergk <martinvonz@google.com>
parents: 44271
diff changeset
   742
        for side, copies in ((b"local", copies1), (b"remote", copies2)):
17e12938f8e7 copies: print debug information about copies per side/branch
Martin von Zweigbergk <martinvonz@google.com>
parents: 44271
diff changeset
   743
            if not copies:
17e12938f8e7 copies: print debug information about copies per side/branch
Martin von Zweigbergk <martinvonz@google.com>
parents: 44271
diff changeset
   744
                continue
17e12938f8e7 copies: print debug information about copies per side/branch
Martin von Zweigbergk <martinvonz@google.com>
parents: 44271
diff changeset
   745
            repo.ui.debug(b"   on %s side:\n" % side)
17e12938f8e7 copies: print debug information about copies per side/branch
Martin von Zweigbergk <martinvonz@google.com>
parents: 44271
diff changeset
   746
            for f in sorted(copies):
17e12938f8e7 copies: print debug information about copies per side/branch
Martin von Zweigbergk <martinvonz@google.com>
parents: 44271
diff changeset
   747
                note = b""
17e12938f8e7 copies: print debug information about copies per side/branch
Martin von Zweigbergk <martinvonz@google.com>
parents: 44271
diff changeset
   748
                if f in copy1 or f in copy2:
17e12938f8e7 copies: print debug information about copies per side/branch
Martin von Zweigbergk <martinvonz@google.com>
parents: 44271
diff changeset
   749
                    note += b"*"
17e12938f8e7 copies: print debug information about copies per side/branch
Martin von Zweigbergk <martinvonz@google.com>
parents: 44271
diff changeset
   750
                if f in divergeset:
17e12938f8e7 copies: print debug information about copies per side/branch
Martin von Zweigbergk <martinvonz@google.com>
parents: 44271
diff changeset
   751
                    note += b"!"
17e12938f8e7 copies: print debug information about copies per side/branch
Martin von Zweigbergk <martinvonz@google.com>
parents: 44271
diff changeset
   752
                if f in renamedeleteset:
17e12938f8e7 copies: print debug information about copies per side/branch
Martin von Zweigbergk <martinvonz@google.com>
parents: 44271
diff changeset
   753
                    note += b"%"
17e12938f8e7 copies: print debug information about copies per side/branch
Martin von Zweigbergk <martinvonz@google.com>
parents: 44271
diff changeset
   754
                repo.ui.debug(
17e12938f8e7 copies: print debug information about copies per side/branch
Martin von Zweigbergk <martinvonz@google.com>
parents: 44271
diff changeset
   755
                    b"    src: '%s' -> dst: '%s' %s\n" % (copies[f], f, note)
17e12938f8e7 copies: print debug information about copies per side/branch
Martin von Zweigbergk <martinvonz@google.com>
parents: 44271
diff changeset
   756
                )
44243
782e0d9c3b74 copies: avoid calculating debug-only stuff without --debug
Martin von Zweigbergk <martinvonz@google.com>
parents: 44242
diff changeset
   757
        del renamedeleteset
782e0d9c3b74 copies: avoid calculating debug-only stuff without --debug
Martin von Zweigbergk <martinvonz@google.com>
parents: 44242
diff changeset
   758
        del divergeset
6274
f3f383efbeae copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
   759
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
   760
    repo.ui.debug(b"  checking for directory renames\n")
6274
f3f383efbeae copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
   761
44271
6ca9f45b32b0 copies: make mergecopies() distinguish between copies on each side
Martin von Zweigbergk <martinvonz@google.com>
parents: 44244
diff changeset
   762
    dirmove1, movewithdir2 = _dir_renames(repo, c1, copy1, copies1, u2)
6ca9f45b32b0 copies: make mergecopies() distinguish between copies on each side
Martin von Zweigbergk <martinvonz@google.com>
parents: 44244
diff changeset
   763
    dirmove2, movewithdir1 = _dir_renames(repo, c2, copy2, copies2, u1)
44244
45192589555c copies: extract function for finding directory renames
Martin von Zweigbergk <martinvonz@google.com>
parents: 44243
diff changeset
   764
44275
fa9ad1da2e77 merge: start using the per-side copy dicts
Martin von Zweigbergk <martinvonz@google.com>
parents: 44274
diff changeset
   765
    branch_copies1 = branch_copies(copy1, renamedelete1, dirmove1, movewithdir1)
fa9ad1da2e77 merge: start using the per-side copy dicts
Martin von Zweigbergk <martinvonz@google.com>
parents: 44274
diff changeset
   766
    branch_copies2 = branch_copies(copy2, renamedelete2, dirmove2, movewithdir2)
44271
6ca9f45b32b0 copies: make mergecopies() distinguish between copies on each side
Martin von Zweigbergk <martinvonz@google.com>
parents: 44244
diff changeset
   767
44275
fa9ad1da2e77 merge: start using the per-side copy dicts
Martin von Zweigbergk <martinvonz@google.com>
parents: 44274
diff changeset
   768
    return branch_copies1, branch_copies2, diverge
44244
45192589555c copies: extract function for finding directory renames
Martin von Zweigbergk <martinvonz@google.com>
parents: 44243
diff changeset
   769
45192589555c copies: extract function for finding directory renames
Martin von Zweigbergk <martinvonz@google.com>
parents: 44243
diff changeset
   770
44271
6ca9f45b32b0 copies: make mergecopies() distinguish between copies on each side
Martin von Zweigbergk <martinvonz@google.com>
parents: 44244
diff changeset
   771
def _dir_renames(repo, ctx, copy, fullcopy, addedfiles):
6ca9f45b32b0 copies: make mergecopies() distinguish between copies on each side
Martin von Zweigbergk <martinvonz@google.com>
parents: 44244
diff changeset
   772
    """Finds moved directories and files that should move with them.
6ca9f45b32b0 copies: make mergecopies() distinguish between copies on each side
Martin von Zweigbergk <martinvonz@google.com>
parents: 44244
diff changeset
   773
6ca9f45b32b0 copies: make mergecopies() distinguish between copies on each side
Martin von Zweigbergk <martinvonz@google.com>
parents: 44244
diff changeset
   774
    ctx: the context for one of the sides
6ca9f45b32b0 copies: make mergecopies() distinguish between copies on each side
Martin von Zweigbergk <martinvonz@google.com>
parents: 44244
diff changeset
   775
    copy: files copied on the same side (as ctx)
6ca9f45b32b0 copies: make mergecopies() distinguish between copies on each side
Martin von Zweigbergk <martinvonz@google.com>
parents: 44244
diff changeset
   776
    fullcopy: files copied on the same side (as ctx), including those that
6ca9f45b32b0 copies: make mergecopies() distinguish between copies on each side
Martin von Zweigbergk <martinvonz@google.com>
parents: 44244
diff changeset
   777
              merge.manifestmerge() won't care about
6ca9f45b32b0 copies: make mergecopies() distinguish between copies on each side
Martin von Zweigbergk <martinvonz@google.com>
parents: 44244
diff changeset
   778
    addedfiles: added files on the other side (compared to ctx)
6ca9f45b32b0 copies: make mergecopies() distinguish between copies on each side
Martin von Zweigbergk <martinvonz@google.com>
parents: 44244
diff changeset
   779
    """
6274
f3f383efbeae copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
   780
    # generate a directory move map
44271
6ca9f45b32b0 copies: make mergecopies() distinguish between copies on each side
Martin von Zweigbergk <martinvonz@google.com>
parents: 44244
diff changeset
   781
    d = ctx.dirs()
17055
8b7cd9a998f0 copies: re-include root directory in directory rename detection (issue3511)
Matt Mackall <mpm@selenic.com>
parents: 16795
diff changeset
   782
    invalid = set()
6274
f3f383efbeae copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
   783
    dirmove = {}
f3f383efbeae copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
   784
f3f383efbeae copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
   785
    # examine each file copy for a potential directory move, which is
f3f383efbeae copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
   786
    # when all the files in a directory are moved to a new directory
43106
d783f945a701 py3: finish porting iteritems() to pycompat and remove source transformer
Gregory Szorc <gregory.szorc@gmail.com>
parents: 43077
diff changeset
   787
    for dst, src in pycompat.iteritems(fullcopy):
25282
0f28815ef066 copies: switch to using pathutil.dirname
Durham Goode <durham@fb.com>
parents: 24782
diff changeset
   788
        dsrc, ddst = pathutil.dirname(src), pathutil.dirname(dst)
6274
f3f383efbeae copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
   789
        if dsrc in invalid:
f3f383efbeae copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
   790
            # already seen to be uninteresting
f3f383efbeae copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
   791
            continue
44271
6ca9f45b32b0 copies: make mergecopies() distinguish between copies on each side
Martin von Zweigbergk <martinvonz@google.com>
parents: 44244
diff changeset
   792
        elif dsrc in d and ddst in d:
6274
f3f383efbeae copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
   793
            # directory wasn't entirely moved locally
39291
eebd591803ab copies: correctly skip directories that have already been considered
Kyle Lippincott <spectral@google.com>
parents: 38670
diff changeset
   794
            invalid.add(dsrc)
eebd591803ab copies: correctly skip directories that have already been considered
Kyle Lippincott <spectral@google.com>
parents: 38670
diff changeset
   795
        elif dsrc in dirmove and dirmove[dsrc] != ddst:
6274
f3f383efbeae copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
   796
            # files from the same directory moved to two different places
39291
eebd591803ab copies: correctly skip directories that have already been considered
Kyle Lippincott <spectral@google.com>
parents: 38670
diff changeset
   797
            invalid.add(dsrc)
6274
f3f383efbeae copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
   798
        else:
f3f383efbeae copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
   799
            # looks good so far
39291
eebd591803ab copies: correctly skip directories that have already been considered
Kyle Lippincott <spectral@google.com>
parents: 38670
diff changeset
   800
            dirmove[dsrc] = ddst
6274
f3f383efbeae copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
   801
f3f383efbeae copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
   802
    for i in invalid:
f3f383efbeae copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
   803
        if i in dirmove:
f3f383efbeae copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
   804
            del dirmove[i]
44271
6ca9f45b32b0 copies: make mergecopies() distinguish between copies on each side
Martin von Zweigbergk <martinvonz@google.com>
parents: 44244
diff changeset
   805
    del d, invalid
6274
f3f383efbeae copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
   806
f3f383efbeae copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
   807
    if not dirmove:
44244
45192589555c copies: extract function for finding directory renames
Martin von Zweigbergk <martinvonz@google.com>
parents: 44243
diff changeset
   808
        return {}, {}
6274
f3f383efbeae copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
   809
43106
d783f945a701 py3: finish porting iteritems() to pycompat and remove source transformer
Gregory Szorc <gregory.szorc@gmail.com>
parents: 43077
diff changeset
   810
    dirmove = {k + b"/": v + b"/" for k, v in pycompat.iteritems(dirmove)}
39291
eebd591803ab copies: correctly skip directories that have already been considered
Kyle Lippincott <spectral@google.com>
parents: 38670
diff changeset
   811
6274
f3f383efbeae copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
   812
    for d in dirmove:
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 43022
diff changeset
   813
        repo.ui.debug(
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
   814
            b"   discovered dir src: '%s' -> dst: '%s'\n" % (d, dirmove[d])
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 43022
diff changeset
   815
        )
6274
f3f383efbeae copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
   816
30183
0106f93ca1d5 checkcopies: move 'movewithdir' initialisation right before its usage
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 30138
diff changeset
   817
    movewithdir = {}
6274
f3f383efbeae copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
   818
    # check unaccounted nonoverlapping files against directory moves
44271
6ca9f45b32b0 copies: make mergecopies() distinguish between copies on each side
Martin von Zweigbergk <martinvonz@google.com>
parents: 44244
diff changeset
   819
    for f in addedfiles:
6274
f3f383efbeae copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
   820
        if f not in fullcopy:
f3f383efbeae copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
   821
            for d in dirmove:
f3f383efbeae copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
   822
                if f.startswith(d):
f3f383efbeae copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
   823
                    # new file added in a directory that was moved, move it
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 43022
diff changeset
   824
                    df = dirmove[d] + f[len(d) :]
6426
e2c49ef2dd6e copies: don't double-detect items in the directory copy check
Matt Mackall <mpm@selenic.com>
parents: 6425
diff changeset
   825
                    if df not in copy:
18134
6c35b53cd28b copies: separate moves via directory renames from explicit copies
Siddharth Agarwal <sid0@fb.com>
parents: 17055
diff changeset
   826
                        movewithdir[f] = df
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 43022
diff changeset
   827
                        repo.ui.debug(
43117
8ff1ecfadcd1 cleanup: join string literals that are already on one line
Martin von Zweigbergk <martinvonz@google.com>
parents: 43106
diff changeset
   828
                            b"   pending file src: '%s' -> dst: '%s'\n"
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 43022
diff changeset
   829
                            % (f, df)
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 43022
diff changeset
   830
                        )
6274
f3f383efbeae copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
   831
                    break
f3f383efbeae copies: move findcopies code to its own module
Matt Mackall <mpm@selenic.com>
parents:
diff changeset
   832
44244
45192589555c copies: extract function for finding directory renames
Martin von Zweigbergk <martinvonz@google.com>
parents: 44243
diff changeset
   833
    return dirmove, movewithdir
19178
4327687ca757 copies: refactor checkcopies() into a top level method
Durham Goode <durham@fb.com>
parents: 18899
diff changeset
   834
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 43022
diff changeset
   835
34191
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34095
diff changeset
   836
def _heuristicscopytracing(repo, c1, c2, base):
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34095
diff changeset
   837
    """ Fast copytracing using filename heuristics
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34095
diff changeset
   838
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34095
diff changeset
   839
    Assumes that moves or renames are of following two types:
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34095
diff changeset
   840
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34095
diff changeset
   841
    1) Inside a directory only (same directory name but different filenames)
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34095
diff changeset
   842
    2) Move from one directory to another
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34095
diff changeset
   843
                    (same filenames but different directory names)
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34095
diff changeset
   844
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34095
diff changeset
   845
    Works only when there are no merge commits in the "source branch".
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34095
diff changeset
   846
    Source branch is commits from base up to c2 not including base.
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34095
diff changeset
   847
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34095
diff changeset
   848
    If merge is involved it fallbacks to _fullcopytracing().
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34095
diff changeset
   849
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34095
diff changeset
   850
    Can be used by setting the following config:
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34095
diff changeset
   851
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34095
diff changeset
   852
        [experimental]
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34095
diff changeset
   853
        copytrace = heuristics
34846
f05a6e015ecc copies: add a config to limit the number of candidates to check in heuristics
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34787
diff changeset
   854
f05a6e015ecc copies: add a config to limit the number of candidates to check in heuristics
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34787
diff changeset
   855
    In some cases the copy/move candidates found by heuristics can be very large
f05a6e015ecc copies: add a config to limit the number of candidates to check in heuristics
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34787
diff changeset
   856
    in number and that will make the algorithm slow. The number of possible
f05a6e015ecc copies: add a config to limit the number of candidates to check in heuristics
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34787
diff changeset
   857
    candidates to check can be limited by using the config
f05a6e015ecc copies: add a config to limit the number of candidates to check in heuristics
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34787
diff changeset
   858
    `experimental.copytrace.movecandidateslimit` which defaults to 100.
34191
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34095
diff changeset
   859
    """
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34095
diff changeset
   860
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34095
diff changeset
   861
    if c1.rev() is None:
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34095
diff changeset
   862
        c1 = c1.p1()
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34095
diff changeset
   863
    if c2.rev() is None:
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34095
diff changeset
   864
        c2 = c2.p1()
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34095
diff changeset
   865
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34095
diff changeset
   866
    changedfiles = set()
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34095
diff changeset
   867
    m1 = c1.manifest()
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
   868
    if not repo.revs(b'%d::%d', base.rev(), c2.rev()):
34191
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34095
diff changeset
   869
        # If base is not in c2 branch, we switch to fullcopytracing
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 43022
diff changeset
   870
        repo.ui.debug(
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
   871
            b"switching to full copytracing as base is not "
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
   872
            b"an ancestor of c2\n"
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 43022
diff changeset
   873
        )
34191
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34095
diff changeset
   874
        return _fullcopytracing(repo, c1, c2, base)
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34095
diff changeset
   875
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34095
diff changeset
   876
    ctx = c2
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34095
diff changeset
   877
    while ctx != base:
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34095
diff changeset
   878
        if len(ctx.parents()) == 2:
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34095
diff changeset
   879
            # To keep things simple let's not handle merges
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
   880
            repo.ui.debug(b"switching to full copytracing because of merges\n")
34191
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34095
diff changeset
   881
            return _fullcopytracing(repo, c1, c2, base)
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34095
diff changeset
   882
        changedfiles.update(ctx.files())
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34095
diff changeset
   883
        ctx = ctx.p1()
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34095
diff changeset
   884
44275
fa9ad1da2e77 merge: start using the per-side copy dicts
Martin von Zweigbergk <martinvonz@google.com>
parents: 44274
diff changeset
   885
    copies2 = {}
34191
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34095
diff changeset
   886
    cp = _forwardcopies(base, c2)
43106
d783f945a701 py3: finish porting iteritems() to pycompat and remove source transformer
Gregory Szorc <gregory.szorc@gmail.com>
parents: 43077
diff changeset
   887
    for dst, src in pycompat.iteritems(cp):
34191
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34095
diff changeset
   888
        if src in m1:
44275
fa9ad1da2e77 merge: start using the per-side copy dicts
Martin von Zweigbergk <martinvonz@google.com>
parents: 44274
diff changeset
   889
            copies2[dst] = src
34191
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34095
diff changeset
   890
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34095
diff changeset
   891
    # file is missing if it isn't present in the destination, but is present in
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34095
diff changeset
   892
    # the base and present in the source.
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34095
diff changeset
   893
    # Presence in the base is important to exclude added files, presence in the
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34095
diff changeset
   894
    # source is important to exclude removed files.
36379
f62369667a7c py3: use list comprehensions instead of filter where we need to eagerly filter
Augie Fackler <augie@google.com>
parents: 36155
diff changeset
   895
    filt = lambda f: f not in m1 and f in base and f in c2
f62369667a7c py3: use list comprehensions instead of filter where we need to eagerly filter
Augie Fackler <augie@google.com>
parents: 36155
diff changeset
   896
    missingfiles = [f for f in changedfiles if filt(f)]
34191
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34095
diff changeset
   897
44275
fa9ad1da2e77 merge: start using the per-side copy dicts
Martin von Zweigbergk <martinvonz@google.com>
parents: 44274
diff changeset
   898
    copies1 = {}
34191
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34095
diff changeset
   899
    if missingfiles:
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34095
diff changeset
   900
        basenametofilename = collections.defaultdict(list)
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34095
diff changeset
   901
        dirnametofilename = collections.defaultdict(list)
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34095
diff changeset
   902
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34095
diff changeset
   903
        for f in m1.filesnotin(base.manifest()):
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34095
diff changeset
   904
            basename = os.path.basename(f)
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34095
diff changeset
   905
            dirname = os.path.dirname(f)
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34095
diff changeset
   906
            basenametofilename[basename].append(f)
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34095
diff changeset
   907
            dirnametofilename[dirname].append(f)
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34095
diff changeset
   908
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34095
diff changeset
   909
        for f in missingfiles:
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34095
diff changeset
   910
            basename = os.path.basename(f)
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34095
diff changeset
   911
            dirname = os.path.dirname(f)
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34095
diff changeset
   912
            samebasename = basenametofilename[basename]
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34095
diff changeset
   913
            samedirname = dirnametofilename[dirname]
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34095
diff changeset
   914
            movecandidates = samebasename + samedirname
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34095
diff changeset
   915
            # f is guaranteed to be present in c2, that's why
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34095
diff changeset
   916
            # c2.filectx(f) won't fail
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34095
diff changeset
   917
            f2 = c2.filectx(f)
34846
f05a6e015ecc copies: add a config to limit the number of candidates to check in heuristics
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34787
diff changeset
   918
            # we can have a lot of candidates which can slow down the heuristics
f05a6e015ecc copies: add a config to limit the number of candidates to check in heuristics
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34787
diff changeset
   919
            # config value to limit the number of candidates moves to check
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 43022
diff changeset
   920
            maxcandidates = repo.ui.configint(
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
   921
                b'experimental', b'copytrace.movecandidateslimit'
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 43022
diff changeset
   922
            )
34846
f05a6e015ecc copies: add a config to limit the number of candidates to check in heuristics
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34787
diff changeset
   923
f05a6e015ecc copies: add a config to limit the number of candidates to check in heuristics
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34787
diff changeset
   924
            if len(movecandidates) > maxcandidates:
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 43022
diff changeset
   925
                repo.ui.status(
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 43022
diff changeset
   926
                    _(
43077
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
   927
                        b"skipping copytracing for '%s', more "
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents: 43076
diff changeset
   928
                        b"candidates than the limit: %d\n"
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 43022
diff changeset
   929
                    )
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 43022
diff changeset
   930
                    % (f, len(movecandidates))
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 43022
diff changeset
   931
                )
34846
f05a6e015ecc copies: add a config to limit the number of candidates to check in heuristics
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34787
diff changeset
   932
                continue
f05a6e015ecc copies: add a config to limit the number of candidates to check in heuristics
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34787
diff changeset
   933
34191
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34095
diff changeset
   934
            for candidate in movecandidates:
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34095
diff changeset
   935
                f1 = c1.filectx(candidate)
37392
a4f02a17420d copies: clean up _related logic
Gábor Stefanik <gabor.stefanik@nng.com>
parents: 36379
diff changeset
   936
                if _related(f1, f2):
34191
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34095
diff changeset
   937
                    # if there are a few related copies then we'll merge
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34095
diff changeset
   938
                    # changes into all of them. This matches the behaviour
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34095
diff changeset
   939
                    # of upstream copytracing
44275
fa9ad1da2e77 merge: start using the per-side copy dicts
Martin von Zweigbergk <martinvonz@google.com>
parents: 44274
diff changeset
   940
                    copies1[candidate] = f
34191
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34095
diff changeset
   941
44275
fa9ad1da2e77 merge: start using the per-side copy dicts
Martin von Zweigbergk <martinvonz@google.com>
parents: 44274
diff changeset
   942
    return branch_copies(copies1), branch_copies(copies2), {}
34191
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core
Pulkit Goyal <7895pulkit@gmail.com>
parents: 34095
diff changeset
   943
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 43022
diff changeset
   944
37392
a4f02a17420d copies: clean up _related logic
Gábor Stefanik <gabor.stefanik@nng.com>
parents: 36379
diff changeset
   945
def _related(f1, f2):
30138
733fb9f7bc92 checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 30137
diff changeset
   946
    """return True if f1 and f2 filectx have a common ancestor
733fb9f7bc92 checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 30137
diff changeset
   947
733fb9f7bc92 checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 30137
diff changeset
   948
    Walk back to common ancestor to see if the two files originate
733fb9f7bc92 checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 30137
diff changeset
   949
    from the same file. Since workingfilectx's rev() is None it messes
733fb9f7bc92 checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 30137
diff changeset
   950
    up the integer comparison logic, hence the pre-step check for
733fb9f7bc92 checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 30137
diff changeset
   951
    None (f1 and f2 can only be workingfilectx's initially).
733fb9f7bc92 checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 30137
diff changeset
   952
    """
733fb9f7bc92 checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 30137
diff changeset
   953
733fb9f7bc92 checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 30137
diff changeset
   954
    if f1 == f2:
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 43022
diff changeset
   955
        return True  # a match
30138
733fb9f7bc92 checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 30137
diff changeset
   956
733fb9f7bc92 checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 30137
diff changeset
   957
    g1, g2 = f1.ancestors(), f2.ancestors()
733fb9f7bc92 checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 30137
diff changeset
   958
    try:
733fb9f7bc92 checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 30137
diff changeset
   959
        f1r, f2r = f1.linkrev(), f2.linkrev()
733fb9f7bc92 checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 30137
diff changeset
   960
733fb9f7bc92 checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 30137
diff changeset
   961
        if f1r is None:
733fb9f7bc92 checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 30137
diff changeset
   962
            f1 = next(g1)
733fb9f7bc92 checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 30137
diff changeset
   963
        if f2r is None:
733fb9f7bc92 checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 30137
diff changeset
   964
            f2 = next(g2)
733fb9f7bc92 checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 30137
diff changeset
   965
733fb9f7bc92 checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 30137
diff changeset
   966
        while True:
733fb9f7bc92 checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 30137
diff changeset
   967
            f1r, f2r = f1.linkrev(), f2.linkrev()
733fb9f7bc92 checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 30137
diff changeset
   968
            if f1r > f2r:
733fb9f7bc92 checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 30137
diff changeset
   969
                f1 = next(g1)
733fb9f7bc92 checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 30137
diff changeset
   970
            elif f2r > f1r:
733fb9f7bc92 checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 30137
diff changeset
   971
                f2 = next(g2)
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 43022
diff changeset
   972
            else:  # f1 and f2 point to files in the same linkrev
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 43022
diff changeset
   973
                return f1 == f2  # true if they point to the same file
30138
733fb9f7bc92 checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 30137
diff changeset
   974
    except StopIteration:
733fb9f7bc92 checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 30137
diff changeset
   975
        return False
733fb9f7bc92 checkcopies: extract the '_related' closure
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents: 30137
diff changeset
   976
43076
2372284d9457 formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents: 43022
diff changeset
   977
44092
833210fbd900 graftcopies: remove `skip` and `repo` arguments
Martin von Zweigbergk <martinvonz@google.com>
parents: 44091
diff changeset
   978
def graftcopies(wctx, ctx, base):
44093
06e7e7652ac0 graftcopies: document why the function is useful at all
Martin von Zweigbergk <martinvonz@google.com>
parents: 44092
diff changeset
   979
    """reproduce copies between base and ctx in the wctx
06e7e7652ac0 graftcopies: document why the function is useful at all
Martin von Zweigbergk <martinvonz@google.com>
parents: 44092
diff changeset
   980
06e7e7652ac0 graftcopies: document why the function is useful at all
Martin von Zweigbergk <martinvonz@google.com>
parents: 44092
diff changeset
   981
    Unlike mergecopies(), this function will only consider copies between base
06e7e7652ac0 graftcopies: document why the function is useful at all
Martin von Zweigbergk <martinvonz@google.com>
parents: 44092
diff changeset
   982
    and ctx; it will ignore copies between base and wctx. Also unlike
06e7e7652ac0 graftcopies: document why the function is useful at all
Martin von Zweigbergk <martinvonz@google.com>
parents: 44092
diff changeset
   983
    mergecopies(), this function will apply copies to the working copy (instead
06e7e7652ac0 graftcopies: document why the function is useful at all
Martin von Zweigbergk <martinvonz@google.com>
parents: 44092
diff changeset
   984
    of just returning information about the copies). That makes it cheaper
06e7e7652ac0 graftcopies: document why the function is useful at all
Martin von Zweigbergk <martinvonz@google.com>
parents: 44092
diff changeset
   985
    (especially in the common case of base==ctx.p1()) and useful also when
06e7e7652ac0 graftcopies: document why the function is useful at all
Martin von Zweigbergk <martinvonz@google.com>
parents: 44092
diff changeset
   986
    experimental.copytrace=off.
06e7e7652ac0 graftcopies: document why the function is useful at all
Martin von Zweigbergk <martinvonz@google.com>
parents: 44092
diff changeset
   987
06e7e7652ac0 graftcopies: document why the function is useful at all
Martin von Zweigbergk <martinvonz@google.com>
parents: 44092
diff changeset
   988
    merge.update() will have already marked most copies, but it will only
06e7e7652ac0 graftcopies: document why the function is useful at all
Martin von Zweigbergk <martinvonz@google.com>
parents: 44092
diff changeset
   989
    mark copies if it thinks the source files are related (see
06e7e7652ac0 graftcopies: document why the function is useful at all
Martin von Zweigbergk <martinvonz@google.com>
parents: 44092
diff changeset
   990
    merge._related()). It will also not mark copies if the file wasn't modified
06e7e7652ac0 graftcopies: document why the function is useful at all
Martin von Zweigbergk <martinvonz@google.com>
parents: 44092
diff changeset
   991
    on the local side. This function adds the copies that were "missed"
06e7e7652ac0 graftcopies: document why the function is useful at all
Martin von Zweigbergk <martinvonz@google.com>
parents: 44092
diff changeset
   992
    by merge.update().
06e7e7652ac0 graftcopies: document why the function is useful at all
Martin von Zweigbergk <martinvonz@google.com>
parents: 44092
diff changeset
   993
    """
44091
3df0bd706c40 graftcopies: use _filter() for filtering out invalid copies
Martin von Zweigbergk <martinvonz@google.com>
parents: 44090
diff changeset
   994
    new_copies = pathcopies(base, ctx)
3df0bd706c40 graftcopies: use _filter() for filtering out invalid copies
Martin von Zweigbergk <martinvonz@google.com>
parents: 44090
diff changeset
   995
    _filter(wctx.p1(), wctx, new_copies)
3df0bd706c40 graftcopies: use _filter() for filtering out invalid copies
Martin von Zweigbergk <martinvonz@google.com>
parents: 44090
diff changeset
   996
    for dst, src in pycompat.iteritems(new_copies):
3df0bd706c40 graftcopies: use _filter() for filtering out invalid copies
Martin von Zweigbergk <martinvonz@google.com>
parents: 44090
diff changeset
   997
        wctx[dst].markcopied(src)