mercurial-scm/hg-stable: mercurial/copies.py annotate

annotate mercurial/copies.py @ 46148:70a9eb899637

copies: document the current algorithm step We are about to reorganise everything and we document the "old" way to clarify the change that leads to the "new way". Differential Revision: https://phab.mercurial-scm.org/D9581

author	Pierre-Yves David <pierre-yves.david@octobus.net>
date	Mon, 14 Dec 2020 11:32:20 +0100
parents	59fa3890d40a
children	294d5aca4ff5

rev	line source
46148 70a9eb899637 copies: document the current algorithm step Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46114 diff changeset	1 # coding: utf8
6274 f3f383efbeae copies: move findcopies code to its own module Matt Mackall <mpm@selenic.com> parents: diff changeset	2 # copies.py - copy detection for Mercurial
f3f383efbeae copies: move findcopies code to its own module Matt Mackall <mpm@selenic.com> parents: diff changeset	3 #
f3f383efbeae copies: move findcopies code to its own module Matt Mackall <mpm@selenic.com> parents: diff changeset	4 # Copyright 2008 Matt Mackall <mpm@selenic.com>
f3f383efbeae copies: move findcopies code to its own module Matt Mackall <mpm@selenic.com> parents: diff changeset	5 #
8225 46293a0c7e9f updated license to be explicit about GPL version 2 Martin Geisler <mg@lazybytes.net> parents: 8209 diff changeset	6 # 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	7 # 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	8
25924 cfc24c22454e copies: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25289 diff changeset	9 from __future__ import absolute_import
cfc24c22454e copies: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25289 diff changeset	10
34191 036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core Pulkit Goyal <7895pulkit@gmail.com> parents: 34095 diff changeset	11 import collections
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core Pulkit Goyal <7895pulkit@gmail.com> parents: 34095 diff changeset	12 import os
6274 f3f383efbeae copies: move findcopies code to its own module Matt Mackall <mpm@selenic.com> parents: diff changeset	13
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	14 from .i18n import _
46114 59fa3890d40a node: import symbols explicitly Joerg Sonnenberger <joerg@bec.de> parents: 46110 diff changeset	15 from .node import (
59fa3890d40a node: import symbols explicitly Joerg Sonnenberger <joerg@bec.de> parents: 46110 diff changeset	16 nullid,
59fa3890d40a node: import symbols explicitly Joerg Sonnenberger <joerg@bec.de> parents: 46110 diff changeset	17 nullrev,
59fa3890d40a node: import symbols explicitly Joerg Sonnenberger <joerg@bec.de> parents: 46110 diff changeset	18 )
43148 843da18386d5 sidedatacopies: deal with upgrading and downgrading to that format Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43147 diff changeset	19
25924 cfc24c22454e copies: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25289 diff changeset	20 from . import (
33886 252fb66ee5bb copies: use intersectmatchers() in non-merge p1 optimization Yuya Nishihara <yuya@tcha.org> parents: 33843 diff changeset	21 match as matchmod,
25924 cfc24c22454e copies: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25289 diff changeset	22 pathutil,
45977 a66568f20ddc copies: use the rust code for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45957 diff changeset	23 policy,
43106 d783f945a701 py3: finish porting iteritems() to pycompat and remove source transformer Gregory Szorc <gregory.szorc@gmail.com> parents: 43077 diff changeset	24 pycompat,
25924 cfc24c22454e copies: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25289 diff changeset	25 util,
cfc24c22454e copies: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25289 diff changeset	26 )
43148 843da18386d5 sidedatacopies: deal with upgrading and downgrading to that format Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43147 diff changeset	27
843da18386d5 sidedatacopies: deal with upgrading and downgrading to that format Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43147 diff changeset	28
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 43022 diff changeset	29 from .utils import stringutil
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 43022 diff changeset	30
46061 e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46040 diff changeset	31 from .revlogutils import (
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46040 diff changeset	32 flagutil,
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46040 diff changeset	33 sidedata as sidedatamod,
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46040 diff changeset	34 )
45672 f877b3628015 copies: return None instead of ChangingFiles when relevant Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45670 diff changeset	35
45977 a66568f20ddc copies: use the rust code for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45957 diff changeset	36 rustmod = policy.importrust("copy_tracing")
a66568f20ddc copies: use the rust code for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45957 diff changeset	37
25924 cfc24c22454e copies: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25289 diff changeset	38
42593 11ceb1b8fd74 copies: inline _chainandfilter() to prepare for next patch Martin von Zweigbergk <martinvonz@google.com> parents: 42592 diff changeset	39 def _filter(src, dst, t):
11ceb1b8fd74 copies: inline _chainandfilter() to prepare for next patch Martin von Zweigbergk <martinvonz@google.com> parents: 42592 diff changeset	40 """filters out invalid copies after chaining"""
42257 d1c2688eda80 copies: document cases in _chain() Martin von Zweigbergk <martinvonz@google.com> parents: 42256 diff changeset	41
42593 11ceb1b8fd74 copies: inline _chainandfilter() to prepare for next patch Martin von Zweigbergk <martinvonz@google.com> parents: 42592 diff changeset	42 # 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	43 # 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	44 # 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	45 # 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	46 # then was renamed between 'mid' and 'dst'.
d1c2688eda80 copies: document cases in _chain() Martin von Zweigbergk <martinvonz@google.com> parents: 42256 diff changeset	47 #
d1c2688eda80 copies: document cases in _chain() Martin von Zweigbergk <martinvonz@google.com> parents: 42256 diff changeset	48 # case src mid dst result
d1c2688eda80 copies: document cases in _chain() Martin von Zweigbergk <martinvonz@google.com> parents: 42256 diff changeset	49 # 1 x y - -
d1c2688eda80 copies: document cases in _chain() Martin von Zweigbergk <martinvonz@google.com> parents: 42256 diff changeset	50 # 2 x y y x->y
d1c2688eda80 copies: document cases in _chain() Martin von Zweigbergk <martinvonz@google.com> parents: 42256 diff changeset	51 # 3 x y x -
d1c2688eda80 copies: document cases in _chain() Martin von Zweigbergk <martinvonz@google.com> parents: 42256 diff changeset	52 # 4 x y z x->z
d1c2688eda80 copies: document cases in _chain() Martin von Zweigbergk <martinvonz@google.com> parents: 42256 diff changeset	53 # 5 - x y -
d1c2688eda80 copies: document cases in _chain() Martin von Zweigbergk <martinvonz@google.com> parents: 42256 diff changeset	54 # 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	55 #
f3d06d37e194 copies: split up _chain() in naive chaining and filtering steps Martin von Zweigbergk <martinvonz@google.com> parents: 42366 diff changeset	56 # _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	57 # 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	58 # 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	59 # 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	60
42395 f3d06d37e194 copies: split up _chain() in naive chaining and filtering steps Martin von Zweigbergk <martinvonz@google.com> parents: 42366 diff changeset	61 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	62 # 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	63 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	64 del t[k]
f3d06d37e194 copies: split up _chain() in naive chaining and filtering steps Martin von Zweigbergk <martinvonz@google.com> parents: 42366 diff changeset	65 # 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	66 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	67 del t[k]
f3d06d37e194 copies: split up _chain() in naive chaining and filtering steps Martin von Zweigbergk <martinvonz@google.com> parents: 42366 diff changeset	68 # 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	69 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	70 del t[k]
f3d06d37e194 copies: split up _chain() in naive chaining and filtering steps Martin von Zweigbergk <martinvonz@google.com> parents: 42366 diff changeset	71
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 43022 diff changeset	72
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	73 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	74 """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	75 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	76 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	77 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	78 return result
15775 91eb4512edd0 copies: rewrite copy detection for non-merge users Matt Mackall <mpm@selenic.com> parents: 15774 diff changeset	79
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 43022 diff changeset	80
43199 069cbbb53cdf copies: drop the findlimit logic Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43198 diff changeset	81 def _tracefile(fctx, am, basemf):
35428 9cf37d111acb copies: consistently use """ for docstrings Martin von Zweigbergk <martinvonz@google.com> parents: 35427 diff changeset	82 """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	83 manifest am
c16fe77e340a pathcopies: give up any optimization based on `introrev` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43148 diff changeset	84
c16fe77e340a pathcopies: give up any optimization based on `introrev` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43148 diff changeset	85 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	86 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	87 disabling that feature."""
15775 91eb4512edd0 copies: rewrite copy detection for non-merge users Matt Mackall <mpm@selenic.com> parents: 15774 diff changeset	88
91eb4512edd0 copies: rewrite copy detection for non-merge users Matt Mackall <mpm@selenic.com> parents: 15774 diff changeset	89 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	90 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	91 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	92 return path
42595 819712deac69 copies: follow copies across merge base without source file (issue6163) Martin von Zweigbergk <martinvonz@google.com> parents: 42594 diff changeset	93 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	94 return path
15775 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
41761 012f695546aa copies: respect narrowmatcher in "parent -> working dir" case Martin von Zweigbergk <martinvonz@google.com> parents: 41735 diff changeset	97 def _dirstatecopies(repo, match=None):
012f695546aa copies: respect narrowmatcher in "parent -> working dir" case Martin von Zweigbergk <martinvonz@google.com> parents: 41735 diff changeset	98 ds = repo.dirstate
15775 91eb4512edd0 copies: rewrite copy detection for non-merge users Matt Mackall <mpm@selenic.com> parents: 15774 diff changeset	99 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	100 for k in list(c):
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	101 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	102 del c[k]
91eb4512edd0 copies: rewrite copy detection for non-merge users Matt Mackall <mpm@selenic.com> parents: 15774 diff changeset	103 return c
91eb4512edd0 copies: rewrite copy detection for non-merge users Matt Mackall <mpm@selenic.com> parents: 15774 diff changeset	104
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 43022 diff changeset	105
24782 4906dc0e038c copies: add matcher parameter to copy logic Durham Goode <durham@fb.com> parents: 24625 diff changeset	106 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	107 """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	108 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	109 files _forwardcopies is about to process.
d7d08337b3f6 copy: move _forwardcopies file logic to a function Durham Goode <durham@fb.com> parents: 24010 diff changeset	110 """
24782 4906dc0e038c copies: add matcher parameter to copy logic Durham Goode <durham@fb.com> parents: 24625 diff changeset	111 ma = a.manifest()
4906dc0e038c copies: add matcher parameter to copy logic Durham Goode <durham@fb.com> parents: 24625 diff changeset	112 mb = b.manifest()
31266 5a909a8098a1 copies: remove use of manifest.matches Durham Goode <durham@fb.com> parents: 30586 diff changeset	113 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	114
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 43022 diff changeset	115
42115 27475ae67676 copies: extract function for deciding whether to use changeset-centric algos Martin von Zweigbergk <martinvonz@google.com> parents: 41941 diff changeset	116 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	117 """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	118 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	119 return True
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	120 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	121 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	122 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	123
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 43022 diff changeset	124
42595 819712deac69 copies: follow copies across merge base without source file (issue6163) Martin von Zweigbergk <martinvonz@google.com> parents: 42594 diff changeset	125 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	126 """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	127 # 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	128 # 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	129 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	130
42115 27475ae67676 copies: extract function for deciding whether to use changeset-centric algos Martin von Zweigbergk <martinvonz@google.com> parents: 41941 diff changeset	131 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	132 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	133
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	134 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	135 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	136 if debug:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	137 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	138 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	139 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	140
15775 91eb4512edd0 copies: rewrite copy detection for non-merge users Matt Mackall <mpm@selenic.com> parents: 15774 diff changeset	141 # find where new files came from
91eb4512edd0 copies: rewrite copy detection for non-merge users Matt Mackall <mpm@selenic.com> parents: 15774 diff changeset	142 # 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	143 # 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	144 cm = {}
28000 d4247c306d82 copies: optimize forward copy detection logic for rebases Durham Goode <durham@fb.com> parents: 27876 diff changeset	145
d4247c306d82 copies: optimize forward copy detection logic for rebases Durham Goode <durham@fb.com> parents: 27876 diff changeset	146 # 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	147 # 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	148 # 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	149 # 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	150 # 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	151 # this comparison.
d4247c306d82 copies: optimize forward copy detection logic for rebases Durham Goode <durham@fb.com> parents: 27876 diff changeset	152 forwardmissingmatch = match
46114 59fa3890d40a node: import symbols explicitly Joerg Sonnenberger <joerg@bec.de> parents: 46110 diff changeset	153 if b.p1() == a and b.p2().node() == nullid:
41941 a791623458ef copies: remove dependency on scmutil by directly using match.exact() Martin von Zweigbergk <martinvonz@google.com> parents: 41937 diff changeset	154 filesmatcher = matchmod.exact(b.files())
33886 252fb66ee5bb copies: use intersectmatchers() in non-merge p1 optimization Yuya Nishihara <yuya@tcha.org> parents: 33843 diff changeset	155 forwardmissingmatch = matchmod.intersectmatchers(match, filesmatcher)
28000 d4247c306d82 copies: optimize forward copy detection logic for rebases Durham Goode <durham@fb.com> parents: 27876 diff changeset	156 missing = _computeforwardmissing(a, b, match=forwardmissingmatch)
d4247c306d82 copies: optimize forward copy detection logic for rebases Durham Goode <durham@fb.com> parents: 27876 diff changeset	157
23980 c1ce5442453f _adjustlinkrev: reuse ancestors set during rename detection (issue4514) Pierre-Yves David <pierre-yves.david@fb.com> parents: 23139 diff changeset	158 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	159
25b2868206e2 copies: add a devel debug mode to trace what copy tracing does Boris Feld <boris.feld@octobus.net> parents: 39967 diff changeset	160 if debug:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	161 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	162
42243 390ec72b8ea4 copies: process files in deterministic order for stable tests Martin von Zweigbergk <martinvonz@google.com> parents: 42211 diff changeset	163 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	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: 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	166 fctx = b[f]
c1ce5442453f _adjustlinkrev: reuse ancestors set during rename detection (issue4514) Pierre-Yves David <pierre-yves.david@fb.com> parents: 23139 diff changeset	167 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	168
40059 cf01616f8d96 copies: add time information to the debug information Boris Feld <boris.feld@octobus.net> parents: 40058 diff changeset	169 if debug:
cf01616f8d96 copies: add time information to the debug information Boris Feld <boris.feld@octobus.net> parents: 40058 diff changeset	170 start = util.timer()
43199 069cbbb53cdf copies: drop the findlimit logic Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43198 diff changeset	171 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	172 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	173 if debug:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	174 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	175 cm[f] = opath
40059 cf01616f8d96 copies: add time information to the debug information Boris Feld <boris.feld@octobus.net> parents: 40058 diff changeset	176 if debug:
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 43022 diff changeset	177 dbg(
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	178 b'debug.copies: time: %f seconds\n'
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 43022 diff changeset	179 % (util.timer() - start)
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 43022 diff changeset	180 )
35429 8801cdcea01f copies: extract method for getting non-wdir forward copies Martin von Zweigbergk <martinvonz@google.com> parents: 35428 diff changeset	181 return cm
8801cdcea01f copies: extract method for getting non-wdir forward copies Martin von Zweigbergk <martinvonz@google.com> parents: 35428 diff changeset	182
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 43022 diff changeset	183
46061 e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46040 diff changeset	184 def _revinfo_getter(repo, match):
45642 2693659c2b34 copies: directly pass a changes object to the copy tracing code Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45641 diff changeset	185 """returns a function that returns the following data given a <rev>"
43255 b8d60845fa5d copies: extract data extraction into a `revinfo` function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43254 diff changeset	186
b8d60845fa5d copies: extract data extraction into a `revinfo` function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43254 diff changeset	187 * 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	188 * p2: revision number of first parent
45642 2693659c2b34 copies: directly pass a changes object to the copy tracing code Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45641 diff changeset	189 * changes: a ChangingFiles object
43255 b8d60845fa5d copies: extract data extraction into a `revinfo` function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43254 diff changeset	190 """
b8d60845fa5d copies: extract data extraction into a `revinfo` function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43254 diff changeset	191 cl = repo.changelog
b8d60845fa5d copies: extract data extraction into a `revinfo` function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43254 diff changeset	192 parents = cl.parentrevs
45672 f877b3628015 copies: return None instead of ChangingFiles when relevant Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45670 diff changeset	193 flags = cl.flags
f877b3628015 copies: return None instead of ChangingFiles when relevant Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45670 diff changeset	194
f877b3628015 copies: return None instead of ChangingFiles when relevant Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45670 diff changeset	195 HASCOPIESINFO = flagutil.REVIDX_HASCOPIESINFO
43255 b8d60845fa5d copies: extract data extraction into a `revinfo` function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43254 diff changeset	196
45640 4f876e6b30fa copies: use dedicated `_revinfo_getter` function and call Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45639 diff changeset	197 changelogrevision = cl.changelogrevision
43257 675c776fbcd1 sidedatacopies: directly fetch copies information from sidedata Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43256 diff changeset	198
45640 4f876e6b30fa copies: use dedicated `_revinfo_getter` function and call Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45639 diff changeset	199 # A small cache to avoid doing the work twice for merges
4f876e6b30fa copies: use dedicated `_revinfo_getter` function and call Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45639 diff changeset	200 #
4f876e6b30fa copies: use dedicated `_revinfo_getter` function and call Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45639 diff changeset	201 # In the vast majority of cases, if we ask information for a revision
4f876e6b30fa copies: use dedicated `_revinfo_getter` function and call Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45639 diff changeset	202 # about 1 parent, we'll later ask it for the other. So it make sense to
4f876e6b30fa copies: use dedicated `_revinfo_getter` function and call Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45639 diff changeset	203 # keep the information around when reaching the first parent of a merge
4f876e6b30fa copies: use dedicated `_revinfo_getter` function and call Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45639 diff changeset	204 # and dropping it after it was provided for the second parents.
4f876e6b30fa copies: use dedicated `_revinfo_getter` function and call Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45639 diff changeset	205 #
4f876e6b30fa copies: use dedicated `_revinfo_getter` function and call Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45639 diff changeset	206 # It exists cases were only one parent of the merge will be walked. It
4f876e6b30fa copies: use dedicated `_revinfo_getter` function and call Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45639 diff changeset	207 # happens when the "destination" the copy tracing is descendant from a
4f876e6b30fa copies: use dedicated `_revinfo_getter` function and call Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45639 diff changeset	208 # new root, not common with the "source". In that case, we will only walk
4f876e6b30fa copies: use dedicated `_revinfo_getter` function and call Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45639 diff changeset	209 # through merge parents that are descendant of changesets common
4f876e6b30fa copies: use dedicated `_revinfo_getter` function and call Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45639 diff changeset	210 # between "source" and "destination".
4f876e6b30fa copies: use dedicated `_revinfo_getter` function and call Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45639 diff changeset	211 #
4f876e6b30fa copies: use dedicated `_revinfo_getter` function and call Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45639 diff changeset	212 # With the current case implementation if such changesets have a copy
4f876e6b30fa copies: use dedicated `_revinfo_getter` function and call Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45639 diff changeset	213 # information, we'll keep them in memory until the end of
4f876e6b30fa copies: use dedicated `_revinfo_getter` function and call Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45639 diff changeset	214 # _changesetforwardcopies. We don't expect the case to be frequent
4f876e6b30fa copies: use dedicated `_revinfo_getter` function and call Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45639 diff changeset	215 # enough to matters.
4f876e6b30fa copies: use dedicated `_revinfo_getter` function and call Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45639 diff changeset	216 #
4f876e6b30fa copies: use dedicated `_revinfo_getter` function and call Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45639 diff changeset	217 # In addition, it would be possible to reach pathological case, were
4f876e6b30fa copies: use dedicated `_revinfo_getter` function and call Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45639 diff changeset	218 # many first parent are met before any second parent is reached. In
4f876e6b30fa copies: use dedicated `_revinfo_getter` function and call Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45639 diff changeset	219 # that case the cache could grow. If this even become an issue one can
4f876e6b30fa copies: use dedicated `_revinfo_getter` function and call Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45639 diff changeset	220 # safely introduce a maximum cache size. This would trade extra CPU/IO
4f876e6b30fa copies: use dedicated `_revinfo_getter` function and call Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45639 diff changeset	221 # time to save memory.
4f876e6b30fa copies: use dedicated `_revinfo_getter` function and call Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45639 diff changeset	222 merge_caches = {}
43301 90213d027154 sidedatacopies: only fetch information once for merge Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43300 diff changeset	223
46061 e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46040 diff changeset	224 alwaysmatch = match.always()
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46040 diff changeset	225
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46040 diff changeset	226 if rustmod is not None and alwaysmatch:
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46040 diff changeset	227
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46040 diff changeset	228 def revinfo(rev):
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46040 diff changeset	229 p1, p2 = parents(rev)
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46040 diff changeset	230 value = None
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46040 diff changeset	231 e = merge_caches.pop(rev, None)
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46040 diff changeset	232 if e is not None:
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46040 diff changeset	233 return e
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46040 diff changeset	234 if flags(rev) & HASCOPIESINFO:
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46040 diff changeset	235 raw = changelogrevision(rev)._sidedata.get(sidedatamod.SD_FILES)
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46040 diff changeset	236 else:
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46040 diff changeset	237 raw = None
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46040 diff changeset	238 value = (p1, p2, raw)
46114 59fa3890d40a node: import symbols explicitly Joerg Sonnenberger <joerg@bec.de> parents: 46110 diff changeset	239 if p1 != nullrev and p2 != nullrev:
46061 e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46040 diff changeset	240 # XXX some case we over cache, IGNORE
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46040 diff changeset	241 merge_caches[rev] = value
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46040 diff changeset	242 return value
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46040 diff changeset	243
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46040 diff changeset	244 else:
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46040 diff changeset	245
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46040 diff changeset	246 def revinfo(rev):
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46040 diff changeset	247 p1, p2 = parents(rev)
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46040 diff changeset	248 value = None
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46040 diff changeset	249 e = merge_caches.pop(rev, None)
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46040 diff changeset	250 if e is not None:
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46040 diff changeset	251 return e
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46040 diff changeset	252 changes = None
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46040 diff changeset	253 if flags(rev) & HASCOPIESINFO:
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46040 diff changeset	254 changes = changelogrevision(rev).changes
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46040 diff changeset	255 value = (p1, p2, changes)
46114 59fa3890d40a node: import symbols explicitly Joerg Sonnenberger <joerg@bec.de> parents: 46110 diff changeset	256 if p1 != nullrev and p2 != nullrev:
46061 e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46040 diff changeset	257 # XXX some case we over cache, IGNORE
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46040 diff changeset	258 merge_caches[rev] = value
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46040 diff changeset	259 return value
43255 b8d60845fa5d copies: extract data extraction into a `revinfo` function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43254 diff changeset	260
b8d60845fa5d copies: extract data extraction into a `revinfo` function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43254 diff changeset	261 return revinfo
b8d60845fa5d copies: extract data extraction into a `revinfo` function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43254 diff changeset	262
b8d60845fa5d copies: extract data extraction into a `revinfo` function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43254 diff changeset	263
45907 06b64fabf91c copies: cache the ancestor checking call when tracing copy Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45821 diff changeset	264 def cached_is_ancestor(is_ancestor):
06b64fabf91c copies: cache the ancestor checking call when tracing copy Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45821 diff changeset	265 """return a cached version of is_ancestor"""
06b64fabf91c copies: cache the ancestor checking call when tracing copy Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45821 diff changeset	266 cache = {}
06b64fabf91c copies: cache the ancestor checking call when tracing copy Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45821 diff changeset	267
06b64fabf91c copies: cache the ancestor checking call when tracing copy Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45821 diff changeset	268 def _is_ancestor(anc, desc):
06b64fabf91c copies: cache the ancestor checking call when tracing copy Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45821 diff changeset	269 if anc > desc:
06b64fabf91c copies: cache the ancestor checking call when tracing copy Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45821 diff changeset	270 return False
06b64fabf91c copies: cache the ancestor checking call when tracing copy Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45821 diff changeset	271 elif anc == desc:
06b64fabf91c copies: cache the ancestor checking call when tracing copy Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45821 diff changeset	272 return True
06b64fabf91c copies: cache the ancestor checking call when tracing copy Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45821 diff changeset	273 key = (anc, desc)
06b64fabf91c copies: cache the ancestor checking call when tracing copy Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45821 diff changeset	274 ret = cache.get(key)
06b64fabf91c copies: cache the ancestor checking call when tracing copy Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45821 diff changeset	275 if ret is None:
06b64fabf91c copies: cache the ancestor checking call when tracing copy Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45821 diff changeset	276 ret = cache[key] = is_ancestor(anc, desc)
06b64fabf91c copies: cache the ancestor checking call when tracing copy Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45821 diff changeset	277 return ret
06b64fabf91c copies: cache the ancestor checking call when tracing copy Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45821 diff changeset	278
06b64fabf91c copies: cache the ancestor checking call when tracing copy Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45821 diff changeset	279 return _is_ancestor
06b64fabf91c copies: cache the ancestor checking call when tracing copy Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45821 diff changeset	280
06b64fabf91c copies: cache the ancestor checking call when tracing copy Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45821 diff changeset	281
41765 49ad315b39ee copies: do copy tracing based on ctx.p[12]copies() if configured Martin von Zweigbergk <martinvonz@google.com> parents: 41763 diff changeset	282 def _changesetforwardcopies(a, b, match):
46114 59fa3890d40a node: import symbols explicitly Joerg Sonnenberger <joerg@bec.de> parents: 46110 diff changeset	283 if a.rev() in (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	284 return {}
49ad315b39ee copies: do copy tracing based on ctx.p[12]copies() if configured Martin von Zweigbergk <martinvonz@google.com> parents: 41763 diff changeset	285
43256 00de32aa834e copies: use an unfiltered repository for the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43255 diff changeset	286 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	287 children = {}
43255 b8d60845fa5d copies: extract data extraction into a `revinfo` function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43254 diff changeset	288
41765 49ad315b39ee copies: do copy tracing based on ctx.p[12]copies() if configured Martin von Zweigbergk <martinvonz@google.com> parents: 41763 diff changeset	289 cl = repo.changelog
45987 8b99c473aae2 copies-rust: move is_ancestor caching within the rust code Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45977 diff changeset	290 isancestor = cl.isancestorrev
41765 49ad315b39ee copies: do copy tracing based on ctx.p[12]copies() if configured Martin von Zweigbergk <martinvonz@google.com> parents: 41763 diff changeset	291 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	292 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	293 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	294 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	295 for p in cl.parentrevs(r):
46114 59fa3890d40a node: import symbols explicitly Joerg Sonnenberger <joerg@bec.de> parents: 46110 diff changeset	296 if p == nullrev:
41765 49ad315b39ee copies: do copy tracing based on ctx.p[12]copies() if configured Martin von Zweigbergk <martinvonz@google.com> parents: 41763 diff changeset	297 continue
49ad315b39ee copies: do copy tracing based on ctx.p[12]copies() if configured Martin von Zweigbergk <martinvonz@google.com> parents: 41763 diff changeset	298 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	299 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	300 else:
49ad315b39ee copies: do copy tracing based on ctx.p[12]copies() if configured Martin von Zweigbergk <martinvonz@google.com> parents: 41763 diff changeset	301 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	302 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	303 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	304 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	305 # 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	306 return {}
83bb1e89ab9b copies: compute the exact set of revision to walk Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43297 diff changeset	307 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	308
43299 83bb1e89ab9b copies: compute the exact set of revision to walk Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43297 diff changeset	309 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	310 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	311 )
83bb1e89ab9b copies: compute the exact set of revision to walk Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43297 diff changeset	312
83bb1e89ab9b copies: compute the exact set of revision to walk Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43297 diff changeset	313 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	314 iterrevs &= mrset
83bb1e89ab9b copies: compute the exact set of revision to walk Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43297 diff changeset	315 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	316 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	317 revs = sorted(iterrevs)
45639 ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	318
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	319 if repo.filecopiesmode == b'changeset-sidedata':
46061 e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46040 diff changeset	320 revinfo = _revinfo_getter(repo, match)
45639 ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	321 return _combine_changeset_copies(
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	322 revs, children, b.rev(), revinfo, match, isancestor
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	323 )
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	324 else:
45640 4f876e6b30fa copies: use dedicated `_revinfo_getter` function and call Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45639 diff changeset	325 revinfo = _revinfo_getter_extra(repo)
45639 ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	326 return _combine_changeset_copies_extra(
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	327 revs, children, b.rev(), revinfo, match, isancestor
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	328 )
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	329
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	330
45627 fb000408bca5 copies: rename some function to the new naming scheme Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45014 diff changeset	331 def _combine_changeset_copies(
44858 45f3f35cefe7 copies: fix the changeset based algorithm regarding merge Pierre-Yves David <pierre-yves.david@octobus.net> parents: 44323 diff changeset	332 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	333 ):
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	334 """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	335
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	336 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	337 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	338 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	339 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	340 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	341
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	342 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	343 """
45977 a66568f20ddc copies: use the rust code for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45957 diff changeset	344
a66568f20ddc copies: use the rust code for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45957 diff changeset	345 alwaysmatch = match.always()
a66568f20ddc copies: use the rust code for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45957 diff changeset	346
a66568f20ddc copies: use the rust code for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45957 diff changeset	347 if rustmod is not None and alwaysmatch:
a66568f20ddc copies: use the rust code for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45957 diff changeset	348 return rustmod.combine_changeset_copies(
a66568f20ddc copies: use the rust code for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45957 diff changeset	349 list(revs), children, targetrev, revinfo, isancestor
a66568f20ddc copies: use the rust code for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45957 diff changeset	350 )
a66568f20ddc copies: use the rust code for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45957 diff changeset	351
45987 8b99c473aae2 copies-rust: move is_ancestor caching within the rust code Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45977 diff changeset	352 isancestor = cached_is_ancestor(isancestor)
8b99c473aae2 copies-rust: move is_ancestor caching within the rust code Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45977 diff changeset	353
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	354 all_copies = {}
46148 70a9eb899637 copies: document the current algorithm step Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46114 diff changeset	355 # iterate over all the "parent" side of copy tracing "edge"
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	356 for r in revs:
46148 70a9eb899637 copies: document the current algorithm step Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46114 diff changeset	357 # fetch potential previously computed data for that parent
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	358 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	359 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	360 # 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	361 copies = {}
46148 70a9eb899637 copies: document the current algorithm step Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46114 diff changeset	362
70a9eb899637 copies: document the current algorithm step Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46114 diff changeset	363 # iterate over all known children to chain the existing data with the
70a9eb899637 copies: document the current algorithm step Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46114 diff changeset	364 # data from the parent → child edge.
42502 5ceb91136ebe copies: avoid unnecessary copying of copy dict Martin von Zweigbergk <martinvonz@google.com> parents: 42501 diff changeset	365 for i, c in enumerate(children[r]):
45642 2693659c2b34 copies: directly pass a changes object to the copy tracing code Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45641 diff changeset	366 p1, p2, changes = revinfo(c)
45672 f877b3628015 copies: return None instead of ChangingFiles when relevant Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45670 diff changeset	367 childcopies = {}
46148 70a9eb899637 copies: document the current algorithm step Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46114 diff changeset	368
70a9eb899637 copies: document the current algorithm step Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46114 diff changeset	369 # select the right parent → child edge
43254 181d28ba05da copies: avoid instancing more changectx to access parent revisions Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43253 diff changeset	370 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	371 parent = 1
45672 f877b3628015 copies: return None instead of ChangingFiles when relevant Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45670 diff changeset	372 if changes is not None:
f877b3628015 copies: return None instead of ChangingFiles when relevant Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45670 diff changeset	373 childcopies = changes.copied_from_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	374 else:
43254 181d28ba05da copies: avoid instancing more changectx to access parent revisions Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43253 diff changeset	375 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	376 parent = 2
45672 f877b3628015 copies: return None instead of ChangingFiles when relevant Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45670 diff changeset	377 if changes is not None:
f877b3628015 copies: return None instead of ChangingFiles when relevant Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45670 diff changeset	378 childcopies = changes.copied_from_p2
42503 c0b51449bf6b copies: avoid calling matcher if matcher.always() Martin von Zweigbergk <martinvonz@google.com> parents: 42502 diff changeset	379 if not alwaysmatch:
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 43022 diff changeset	380 childcopies = {
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 43022 diff changeset	381 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	382 }
46148 70a9eb899637 copies: document the current algorithm step Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46114 diff changeset	383
70a9eb899637 copies: document the current algorithm step Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46114 diff changeset	384 # chain the data in the edge with the existing data
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	385 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	386 if childcopies:
44858 45f3f35cefe7 copies: fix the changeset based algorithm regarding merge Pierre-Yves David <pierre-yves.david@octobus.net> parents: 44323 diff changeset	387 newcopies = copies.copy()
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge Pierre-Yves David <pierre-yves.david@octobus.net> parents: 44323 diff changeset	388 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	389 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	390 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	391 source = prev[1]
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge Pierre-Yves David <pierre-yves.david@octobus.net> parents: 44323 diff changeset	392 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	393 assert newcopies is not copies
46000 b6b7626d3e06 copies: avoid unwanted side effect from one branch to another Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45992 diff changeset	394 if changes is not None and changes.removed:
b6b7626d3e06 copies: avoid unwanted side effect from one branch to another Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45992 diff changeset	395 if newcopies is copies:
b6b7626d3e06 copies: avoid unwanted side effect from one branch to another Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45992 diff changeset	396 newcopies = copies.copy()
45672 f877b3628015 copies: return None instead of ChangingFiles when relevant Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45670 diff changeset	397 for f in changes.removed:
f877b3628015 copies: return None instead of ChangingFiles when relevant Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45670 diff changeset	398 if f in newcopies:
f877b3628015 copies: return None instead of ChangingFiles when relevant Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45670 diff changeset	399 if newcopies is copies:
f877b3628015 copies: return None instead of ChangingFiles when relevant Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45670 diff changeset	400 # copy on write to avoid affecting potential other
f877b3628015 copies: return None instead of ChangingFiles when relevant Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45670 diff changeset	401 # branches. when there are no other branches, this
f877b3628015 copies: return None instead of ChangingFiles when relevant Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45670 diff changeset	402 # could be avoided.
f877b3628015 copies: return None instead of ChangingFiles when relevant Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45670 diff changeset	403 newcopies = copies.copy()
f877b3628015 copies: return None instead of ChangingFiles when relevant Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45670 diff changeset	404 newcopies[f] = (c, None)
46148 70a9eb899637 copies: document the current algorithm step Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46114 diff changeset	405
70a9eb899637 copies: document the current algorithm step Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46114 diff changeset	406 # check potential need to combine the data from another parent (for
70a9eb899637 copies: document the current algorithm step Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46114 diff changeset	407 # that child). See comment below for details.
43252 32187ae9eeb3 copies: simplify the handling of merges Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43231 diff changeset	408 othercopies = all_copies.get(c)
32187ae9eeb3 copies: simplify the handling of merges Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43231 diff changeset	409 if othercopies is None:
32187ae9eeb3 copies: simplify the handling of merges Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43231 diff changeset	410 all_copies[c] = newcopies
45991 cf04af3a5ef1 copies: fast path no-op merge Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45987 diff changeset	411 elif newcopies is othercopies:
cf04af3a5ef1 copies: fast path no-op merge Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45987 diff changeset	412 # nothing to merge:
cf04af3a5ef1 copies: fast path no-op merge Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45987 diff changeset	413 pass
43252 32187ae9eeb3 copies: simplify the handling of merges Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43231 diff changeset	414 else:
32187ae9eeb3 copies: simplify the handling of merges Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43231 diff changeset	415 # 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	416 # work with the other.
32187ae9eeb3 copies: simplify the handling of merges Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43231 diff changeset	417 #
32187ae9eeb3 copies: simplify the handling of merges Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43231 diff changeset	418 # 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	419 # 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	420 # 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	421 # potential filelog related behavior.
32187ae9eeb3 copies: simplify the handling of merges Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43231 diff changeset	422 if parent == 1:
46040 8d54944eaeb0 copies: properly copies parent dictionary before updating it Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46026 diff changeset	423 if newcopies is copies:
8d54944eaeb0 copies: properly copies parent dictionary before updating it Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46026 diff changeset	424 newcopies = copies.copy()
45992 7d3c51c728c9 copies: simplify the call to _merge_copies_dict Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45991 diff changeset	425 minor, major = othercopies, newcopies
43252 32187ae9eeb3 copies: simplify the handling of merges Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43231 diff changeset	426 else:
46040 8d54944eaeb0 copies: properly copies parent dictionary before updating it Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46026 diff changeset	427 # we do not know if the other dict is a copy or not, so we
8d54944eaeb0 copies: properly copies parent dictionary before updating it Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46026 diff changeset	428 # need to blindly copy it. Future change should make this
8d54944eaeb0 copies: properly copies parent dictionary before updating it Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46026 diff changeset	429 # unnecessary.
8d54944eaeb0 copies: properly copies parent dictionary before updating it Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46026 diff changeset	430 minor, major = newcopies, othercopies.copy()
46001 f9f8d8aa9a92 copies: clarify the return of _merge_copies_dict Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46000 diff changeset	431 copies = _merge_copies_dict(minor, major, isancestor, changes)
f9f8d8aa9a92 copies: clarify the return of _merge_copies_dict Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46000 diff changeset	432 all_copies[c] = copies
44858 45f3f35cefe7 copies: fix the changeset based algorithm regarding merge Pierre-Yves David <pierre-yves.david@octobus.net> parents: 44323 diff changeset	433
46148 70a9eb899637 copies: document the current algorithm step Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46114 diff changeset	434 # filter out internal details and return a {dest: source mapping}
44858 45f3f35cefe7 copies: fix the changeset based algorithm regarding merge Pierre-Yves David <pierre-yves.david@octobus.net> parents: 44323 diff changeset	435 final_copies = {}
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge Pierre-Yves David <pierre-yves.david@octobus.net> parents: 44323 diff changeset	436 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	437 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	438 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	439 return final_copies
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge Pierre-Yves David <pierre-yves.david@octobus.net> parents: 44323 diff changeset	440
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge Pierre-Yves David <pierre-yves.david@octobus.net> parents: 44323 diff changeset	441
45642 2693659c2b34 copies: directly pass a changes object to the copy tracing code Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45641 diff changeset	442 def _merge_copies_dict(minor, major, isancestor, changes):
44858 45f3f35cefe7 copies: fix the changeset based algorithm regarding merge Pierre-Yves David <pierre-yves.david@octobus.net> parents: 44323 diff changeset	443 """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	444
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge Pierre-Yves David <pierre-yves.david@octobus.net> parents: 44323 diff changeset	445 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	446
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge Pierre-Yves David <pierre-yves.david@octobus.net> parents: 44323 diff changeset	447 - `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	448 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	449
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge Pierre-Yves David <pierre-yves.david@octobus.net> parents: 44323 diff changeset	450 - `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	451 current revision,
46001 f9f8d8aa9a92 copies: clarify the return of _merge_copies_dict Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46000 diff changeset	452
f9f8d8aa9a92 copies: clarify the return of _merge_copies_dict Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46000 diff changeset	453 return the resulting dict (in practice, the "minor" object, updated)
44858 45f3f35cefe7 copies: fix the changeset based algorithm regarding merge Pierre-Yves David <pierre-yves.david@octobus.net> parents: 44323 diff changeset	454 """
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge Pierre-Yves David <pierre-yves.david@octobus.net> parents: 44323 diff changeset	455 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	456 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	457 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	458 minor[dest] = value
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge Pierre-Yves David <pierre-yves.david@octobus.net> parents: 44323 diff changeset	459 else:
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge Pierre-Yves David <pierre-yves.david@octobus.net> parents: 44323 diff changeset	460 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	461 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	462 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	463 continue
45f3f35cefe7 copies: fix the changeset based algorithm regarding merge Pierre-Yves David <pierre-yves.david@octobus.net> parents: 44323 diff changeset	464 # 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	465 # than the branch point or there is a merge
45670 a8fb29b05f92 salvaged: properly deal with salvaged file during copy tracing Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45642 diff changeset	466 if new_tt == other_tt:
a8fb29b05f92 salvaged: properly deal with salvaged file during copy tracing Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45642 diff changeset	467 minor[dest] = value
45672 f877b3628015 copies: return None instead of ChangingFiles when relevant Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45670 diff changeset	468 elif (
f877b3628015 copies: return None instead of ChangingFiles when relevant Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45670 diff changeset	469 changes is not None
f877b3628015 copies: return None instead of ChangingFiles when relevant Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45670 diff changeset	470 and value[1] is None
f877b3628015 copies: return None instead of ChangingFiles when relevant Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45670 diff changeset	471 and dest in changes.salvaged
f877b3628015 copies: return None instead of ChangingFiles when relevant Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45670 diff changeset	472 ):
45670 a8fb29b05f92 salvaged: properly deal with salvaged file during copy tracing Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45642 diff changeset	473 pass
45672 f877b3628015 copies: return None instead of ChangingFiles when relevant Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45670 diff changeset	474 elif (
f877b3628015 copies: return None instead of ChangingFiles when relevant Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45670 diff changeset	475 changes is not None
f877b3628015 copies: return None instead of ChangingFiles when relevant Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45670 diff changeset	476 and other[1] is None
f877b3628015 copies: return None instead of ChangingFiles when relevant Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45670 diff changeset	477 and dest in changes.salvaged
f877b3628015 copies: return None instead of ChangingFiles when relevant Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45670 diff changeset	478 ):
45670 a8fb29b05f92 salvaged: properly deal with salvaged file during copy tracing Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45642 diff changeset	479 minor[dest] = value
45673 7990e7d957b0 copies: move `merged` testing sooner Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45672 diff changeset	480 elif changes is not None and dest in changes.merged:
45670 a8fb29b05f92 salvaged: properly deal with salvaged file during copy tracing Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45642 diff changeset	481 minor[dest] = value
45673 7990e7d957b0 copies: move `merged` testing sooner Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45672 diff changeset	482 elif not isancestor(new_tt, other_tt):
45821 ff7e0ca666e8 copies: make sure deleted copy info do not overwriting unrelated ones Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45673 diff changeset	483 if value[1] is not None:
ff7e0ca666e8 copies: make sure deleted copy info do not overwriting unrelated ones Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45673 diff changeset	484 minor[dest] = value
ff7e0ca666e8 copies: make sure deleted copy info do not overwriting unrelated ones Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45673 diff changeset	485 elif isancestor(other_tt, new_tt):
ff7e0ca666e8 copies: make sure deleted copy info do not overwriting unrelated ones Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45673 diff changeset	486 minor[dest] = value
46001 f9f8d8aa9a92 copies: clarify the return of _merge_copies_dict Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46000 diff changeset	487 return minor
41765 49ad315b39ee copies: do copy tracing based on ctx.p[12]copies() if configured Martin von Zweigbergk <martinvonz@google.com> parents: 41763 diff changeset	488
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 43022 diff changeset	489
45640 4f876e6b30fa copies: use dedicated `_revinfo_getter` function and call Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45639 diff changeset	490 def _revinfo_getter_extra(repo):
4f876e6b30fa copies: use dedicated `_revinfo_getter` function and call Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45639 diff changeset	491 """return a function that return multiple data given a <rev>"i
4f876e6b30fa copies: use dedicated `_revinfo_getter` function and call Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45639 diff changeset	492
4f876e6b30fa copies: use dedicated `_revinfo_getter` function and call Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45639 diff changeset	493 * p1: revision number of first parent
4f876e6b30fa copies: use dedicated `_revinfo_getter` function and call Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45639 diff changeset	494 * p2: revision number of first parent
4f876e6b30fa copies: use dedicated `_revinfo_getter` function and call Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45639 diff changeset	495 * p1copies: mapping of copies from p1
4f876e6b30fa copies: use dedicated `_revinfo_getter` function and call Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45639 diff changeset	496 * p2copies: mapping of copies from p2
4f876e6b30fa copies: use dedicated `_revinfo_getter` function and call Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45639 diff changeset	497 * removed: a list of removed files
4f876e6b30fa copies: use dedicated `_revinfo_getter` function and call Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45639 diff changeset	498 * ismerged: a callback to know if file was merged in that revision
4f876e6b30fa copies: use dedicated `_revinfo_getter` function and call Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45639 diff changeset	499 """
4f876e6b30fa copies: use dedicated `_revinfo_getter` function and call Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45639 diff changeset	500 cl = repo.changelog
4f876e6b30fa copies: use dedicated `_revinfo_getter` function and call Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45639 diff changeset	501 parents = cl.parentrevs
4f876e6b30fa copies: use dedicated `_revinfo_getter` function and call Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45639 diff changeset	502
4f876e6b30fa copies: use dedicated `_revinfo_getter` function and call Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45639 diff changeset	503 def get_ismerged(rev):
4f876e6b30fa copies: use dedicated `_revinfo_getter` function and call Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45639 diff changeset	504 ctx = repo[rev]
4f876e6b30fa copies: use dedicated `_revinfo_getter` function and call Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45639 diff changeset	505
4f876e6b30fa copies: use dedicated `_revinfo_getter` function and call Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45639 diff changeset	506 def ismerged(path):
4f876e6b30fa copies: use dedicated `_revinfo_getter` function and call Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45639 diff changeset	507 if path not in ctx.files():
4f876e6b30fa copies: use dedicated `_revinfo_getter` function and call Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45639 diff changeset	508 return False
4f876e6b30fa copies: use dedicated `_revinfo_getter` function and call Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45639 diff changeset	509 fctx = ctx[path]
4f876e6b30fa copies: use dedicated `_revinfo_getter` function and call Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45639 diff changeset	510 parents = fctx._filelog.parents(fctx._filenode)
4f876e6b30fa copies: use dedicated `_revinfo_getter` function and call Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45639 diff changeset	511 nb_parents = 0
4f876e6b30fa copies: use dedicated `_revinfo_getter` function and call Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45639 diff changeset	512 for n in parents:
46114 59fa3890d40a node: import symbols explicitly Joerg Sonnenberger <joerg@bec.de> parents: 46110 diff changeset	513 if n != nullid:
45640 4f876e6b30fa copies: use dedicated `_revinfo_getter` function and call Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45639 diff changeset	514 nb_parents += 1
4f876e6b30fa copies: use dedicated `_revinfo_getter` function and call Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45639 diff changeset	515 return nb_parents >= 2
4f876e6b30fa copies: use dedicated `_revinfo_getter` function and call Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45639 diff changeset	516
4f876e6b30fa copies: use dedicated `_revinfo_getter` function and call Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45639 diff changeset	517 return ismerged
4f876e6b30fa copies: use dedicated `_revinfo_getter` function and call Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45639 diff changeset	518
4f876e6b30fa copies: use dedicated `_revinfo_getter` function and call Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45639 diff changeset	519 def revinfo(rev):
4f876e6b30fa copies: use dedicated `_revinfo_getter` function and call Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45639 diff changeset	520 p1, p2 = parents(rev)
4f876e6b30fa copies: use dedicated `_revinfo_getter` function and call Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45639 diff changeset	521 ctx = repo[rev]
4f876e6b30fa copies: use dedicated `_revinfo_getter` function and call Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45639 diff changeset	522 p1copies, p2copies = ctx._copies
4f876e6b30fa copies: use dedicated `_revinfo_getter` function and call Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45639 diff changeset	523 removed = ctx.filesremoved()
4f876e6b30fa copies: use dedicated `_revinfo_getter` function and call Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45639 diff changeset	524 return p1, p2, p1copies, p2copies, removed, get_ismerged(rev)
4f876e6b30fa copies: use dedicated `_revinfo_getter` function and call Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45639 diff changeset	525
4f876e6b30fa copies: use dedicated `_revinfo_getter` function and call Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45639 diff changeset	526 return revinfo
4f876e6b30fa copies: use dedicated `_revinfo_getter` function and call Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45639 diff changeset	527
4f876e6b30fa copies: use dedicated `_revinfo_getter` function and call Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45639 diff changeset	528
45639 ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	529 def _combine_changeset_copies_extra(
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	530 revs, children, targetrev, revinfo, match, isancestor
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	531 ):
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	532 """version of `_combine_changeset_copies` that works with the Google
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	533 specific "extra" based storage for copy information"""
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	534 all_copies = {}
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	535 alwaysmatch = match.always()
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	536 for r in revs:
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	537 copies = all_copies.pop(r, None)
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	538 if copies is None:
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	539 # this is a root
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	540 copies = {}
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	541 for i, c in enumerate(children[r]):
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	542 p1, p2, p1copies, p2copies, removed, ismerged = revinfo(c)
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	543 if r == p1:
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	544 parent = 1
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	545 childcopies = p1copies
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	546 else:
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	547 assert r == p2
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	548 parent = 2
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	549 childcopies = p2copies
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	550 if not alwaysmatch:
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	551 childcopies = {
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	552 dst: src for dst, src in childcopies.items() if match(dst)
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	553 }
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	554 newcopies = copies
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	555 if childcopies:
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	556 newcopies = copies.copy()
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	557 for dest, source in pycompat.iteritems(childcopies):
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	558 prev = copies.get(source)
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	559 if prev is not None and prev[1] is not None:
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	560 source = prev[1]
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	561 newcopies[dest] = (c, source)
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	562 assert newcopies is not copies
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	563 for f in removed:
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	564 if f in newcopies:
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	565 if newcopies is copies:
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	566 # copy on write to avoid affecting potential other
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	567 # branches. when there are no other branches, this
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	568 # could be avoided.
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	569 newcopies = copies.copy()
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	570 newcopies[f] = (c, None)
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	571 othercopies = all_copies.get(c)
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	572 if othercopies is None:
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	573 all_copies[c] = newcopies
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	574 else:
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	575 # we are the second parent to work on c, we need to merge our
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	576 # work with the other.
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	577 #
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	578 # In case of conflict, parent 1 take precedence over parent 2.
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	579 # This is an arbitrary choice made anew when implementing
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	580 # changeset based copies. It was made without regards with
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	581 # potential filelog related behavior.
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	582 if parent == 1:
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	583 _merge_copies_dict_extra(
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	584 othercopies, newcopies, isancestor, ismerged
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	585 )
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	586 else:
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	587 _merge_copies_dict_extra(
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	588 newcopies, othercopies, isancestor, ismerged
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	589 )
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	590 all_copies[c] = newcopies
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	591
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	592 final_copies = {}
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	593 for dest, (tt, source) in all_copies[targetrev].items():
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	594 if source is not None:
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	595 final_copies[dest] = source
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	596 return final_copies
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	597
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	598
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	599 def _merge_copies_dict_extra(minor, major, isancestor, ismerged):
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	600 """version of `_merge_copies_dict` that works with the Google
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	601 specific "extra" based storage for copy information"""
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	602 for dest, value in major.items():
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	603 other = minor.get(dest)
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	604 if other is None:
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	605 minor[dest] = value
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	606 else:
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	607 new_tt = value[0]
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	608 other_tt = other[0]
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	609 if value[1] == other[1]:
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	610 continue
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	611 # content from "major" wins, unless it is older
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	612 # than the branch point or there is a merge
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	613 if (
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	614 new_tt == other_tt
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	615 or not isancestor(new_tt, other_tt)
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	616 or ismerged(dest)
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	617 ):
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	618 minor[dest] = value
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	619
ad6ebb6f0dfe copies: make two version of the changeset centric algorithm Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45627 diff changeset	620
42595 819712deac69 copies: follow copies across merge base without source file (issue6163) Martin von Zweigbergk <martinvonz@google.com> parents: 42594 diff changeset	621 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	622 """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	623
42595 819712deac69 copies: follow copies across merge base without source file (issue6163) Martin von Zweigbergk <martinvonz@google.com> parents: 42594 diff changeset	624 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	625 base = a
40422 873f3682c8af narrow: make copies.pathcopies() filter with narrowspec again Martin von Zweigbergk <martinvonz@google.com> parents: 40077 diff changeset	626 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	627 # check for working copy
8801cdcea01f copies: extract method for getting non-wdir forward copies Martin von Zweigbergk <martinvonz@google.com> parents: 35428 diff changeset	628 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	629 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	630 # 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	631 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	632 else:
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 43022 diff changeset	633 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	634 return copies
15775 91eb4512edd0 copies: rewrite copy detection for non-merge users Matt Mackall <mpm@selenic.com> parents: 15774 diff changeset	635
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 43022 diff changeset	636
41762 3158cb74fbca copies: make _backwardrenames() filter out copies by destination Martin von Zweigbergk <martinvonz@google.com> parents: 41761 diff changeset	637 def _backwardrenames(a, b, match):
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	638 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	639 return {}
38f92d12357c copy: add flag for disabling copy tracing Durham Goode <durham@fb.com> parents: 25924 diff changeset	640
18136 f23dea2b296e copies: do not track backward copies, only renames (issue3739) Siddharth Agarwal <sid0@fb.com> parents: 18135 diff changeset	641 # 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	642 # 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	643 # 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	644 # 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	645 # 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	646 # to filter the source instead.
15775 91eb4512edd0 copies: rewrite copy detection for non-merge users Matt Mackall <mpm@selenic.com> parents: 15774 diff changeset	647 f = _forwardcopies(b, a)
91eb4512edd0 copies: rewrite copy detection for non-merge users Matt Mackall <mpm@selenic.com> parents: 15774 diff changeset	648 r = {}
43106 d783f945a701 py3: finish porting iteritems() to pycompat and remove source transformer Gregory Szorc <gregory.szorc@gmail.com> parents: 43077 diff changeset	649 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	650 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	651 continue
18136 f23dea2b296e copies: do not track backward copies, only renames (issue3739) Siddharth Agarwal <sid0@fb.com> parents: 18135 diff changeset	652 # remove copies
f23dea2b296e copies: do not track backward copies, only renames (issue3739) Siddharth Agarwal <sid0@fb.com> parents: 18135 diff changeset	653 if v in a:
f23dea2b296e copies: do not track backward copies, only renames (issue3739) Siddharth Agarwal <sid0@fb.com> parents: 18135 diff changeset	654 continue
15775 91eb4512edd0 copies: rewrite copy detection for non-merge users Matt Mackall <mpm@selenic.com> parents: 15774 diff changeset	655 r[v] = k
91eb4512edd0 copies: rewrite copy detection for non-merge users Matt Mackall <mpm@selenic.com> parents: 15774 diff changeset	656 return r
91eb4512edd0 copies: rewrite copy detection for non-merge users Matt Mackall <mpm@selenic.com> parents: 15774 diff changeset	657
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 43022 diff changeset	658
24782 4906dc0e038c copies: add matcher parameter to copy logic Durham Goode <durham@fb.com> parents: 24625 diff changeset	659 def pathcopies(x, y, match=None):
35428 9cf37d111acb copies: consistently use """ for docstrings Martin von Zweigbergk <martinvonz@google.com> parents: 35427 diff changeset	660 """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	661 repo = x._repo
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	662 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	663 if debug:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	664 repo.ui.debug(
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	665 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	666 )
15775 91eb4512edd0 copies: rewrite copy detection for non-merge users Matt Mackall <mpm@selenic.com> parents: 15774 diff changeset	667 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	668 return {}
44323 30862e226339 copies: avoid filtering by short-circuit dirstate-only copies earlier Martin von Zweigbergk <martinvonz@google.com> parents: 44299 diff changeset	669 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	670 if debug:
30862e226339 copies: avoid filtering by short-circuit dirstate-only copies earlier Martin von Zweigbergk <martinvonz@google.com> parents: 44299 diff changeset	671 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	672 # 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	673 return _dirstatecopies(repo, match)
15775 91eb4512edd0 copies: rewrite copy detection for non-merge users Matt Mackall <mpm@selenic.com> parents: 15774 diff changeset	674 a = y.ancestor(x)
91eb4512edd0 copies: rewrite copy detection for non-merge users Matt Mackall <mpm@selenic.com> parents: 15774 diff changeset	675 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	676 if debug:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	677 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	678 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	679 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	680 if debug:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	681 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	682 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	683 else:
a48f6f18dc6d copies: remove most early returns from pathcopies() and _forwardcopies() Martin von Zweigbergk <martinvonz@google.com> parents: 42591 diff changeset	684 if debug:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	685 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	686 base = None
46114 59fa3890d40a node: import symbols explicitly Joerg Sonnenberger <joerg@bec.de> parents: 46110 diff changeset	687 if a.rev() != nullrev:
42595 819712deac69 copies: follow copies across merge base without source file (issue6163) Martin von Zweigbergk <martinvonz@google.com> parents: 42594 diff changeset	688 base = x
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 43022 diff changeset	689 copies = _chain(
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 43022 diff changeset	690 _backwardrenames(x, a, match=match),
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 43022 diff changeset	691 _forwardcopies(a, y, base, match=match),
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 43022 diff changeset	692 )
42594 d013099c551b copies: filter invalid copies only at end of pathcopies() (issue6163) Martin von Zweigbergk <martinvonz@google.com> parents: 42593 diff changeset	693 _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	694 return copies
15774 0bd17a4bed88 copies: split the copies api for "normal" and merge cases (API) Matt Mackall <mpm@selenic.com> parents: 14494 diff changeset	695
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 43022 diff changeset	696
30186 f7ed5af31242 mergecopies: rename 'ca' to 'base' Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 30185 diff changeset	697 def mergecopies(repo, c1, c2, base):
6274 f3f383efbeae copies: move findcopies code to its own module Matt Mackall <mpm@selenic.com> parents: diff changeset	698 """
42118 967c098eed33 copies: move comment about implementation of mergecopies() to end Martin von Zweigbergk <martinvonz@google.com> parents: 42115 diff changeset	699 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	700 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	701
b4b196092cc3 copytrace: move the default copytracing algorithm in a new function Pulkit Goyal <7895pulkit@gmail.com> parents: 34094 diff changeset	702 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	703 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	704 For example:
33843 42ad7cc645a4 copies: add more details to the documentation of mergecopies() Pulkit Goyal <7895pulkit@gmail.com> parents: 32663 diff changeset	705
42ad7cc645a4 copies: add more details to the documentation of mergecopies() Pulkit Goyal <7895pulkit@gmail.com> parents: 32663 diff changeset	706 o ---> 4 another commit
42ad7cc645a4 copies: add more details to the documentation of mergecopies() Pulkit Goyal <7895pulkit@gmail.com> parents: 32663 diff changeset	707 \|
42ad7cc645a4 copies: add more details to the documentation of mergecopies() Pulkit Goyal <7895pulkit@gmail.com> parents: 32663 diff changeset	708 \| 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	709 \| /
42ad7cc645a4 copies: add more details to the documentation of mergecopies() Pulkit Goyal <7895pulkit@gmail.com> parents: 32663 diff changeset	710 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	711 \|/
42ad7cc645a4 copies: add more details to the documentation of mergecopies() Pulkit Goyal <7895pulkit@gmail.com> parents: 32663 diff changeset	712 o ---> 1 merge base
42ad7cc645a4 copies: add more details to the documentation of mergecopies() Pulkit Goyal <7895pulkit@gmail.com> parents: 32663 diff changeset	713
42ad7cc645a4 copies: add more details to the documentation of mergecopies() Pulkit Goyal <7895pulkit@gmail.com> parents: 32663 diff changeset	714 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	715 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	716 message:
42ad7cc645a4 copies: add more details to the documentation of mergecopies() Pulkit Goyal <7895pulkit@gmail.com> parents: 32663 diff changeset	717
42ad7cc645a4 copies: add more details to the documentation of mergecopies() Pulkit Goyal <7895pulkit@gmail.com> parents: 32663 diff changeset	718 ```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	719
44274 7f8bdee0034e copies: define a type to return from mergecopies() Martin von Zweigbergk <martinvonz@google.com> parents: 44272 diff changeset	720 Returns a tuple where:
16168 7bbabfe25321 copies: add docstring for mergecopies Matt Mackall <mpm@selenic.com> parents: 15994 diff changeset	721
44274 7f8bdee0034e copies: define a type to return from mergecopies() Martin von Zweigbergk <martinvonz@google.com> parents: 44272 diff changeset	722 "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	723
16168 7bbabfe25321 copies: add docstring for mergecopies Matt Mackall <mpm@selenic.com> parents: 15994 diff changeset	724 "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	725 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	726
42118 967c098eed33 copies: move comment about implementation of mergecopies() to end Martin von Zweigbergk <martinvonz@google.com> parents: 42115 diff changeset	727 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	728 """
f3f383efbeae copies: move findcopies code to its own module Matt Mackall <mpm@selenic.com> parents: diff changeset	729 # 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	730 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	731 return branch_copies(), branch_copies(), {}
6274 f3f383efbeae copies: move findcopies code to its own module Matt Mackall <mpm@selenic.com> parents: diff changeset	732
41761 012f695546aa copies: respect narrowmatcher in "parent -> working dir" case Martin von Zweigbergk <martinvonz@google.com> parents: 41735 diff changeset	733 narrowmatch = c1.repo().narrowmatch()
012f695546aa copies: respect narrowmatcher in "parent -> working dir" case Martin von Zweigbergk <martinvonz@google.com> parents: 41735 diff changeset	734
6646 9eb274d773d9 copies: teach copies about dirstate.copies Matt Mackall <mpm@selenic.com> parents: 6431 diff changeset	735 # avoid silly behavior for parent -> working dir
13878 a8d13ee0ce68 misc: replace .parents()[0] with p1() Matt Mackall <mpm@selenic.com> parents: 12683 diff changeset	736 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	737 return (
fa9ad1da2e77 merge: start using the per-side copy dicts Martin von Zweigbergk <martinvonz@google.com> parents: 44274 diff changeset	738 branch_copies(_dirstatecopies(repo, narrowmatch)),
fa9ad1da2e77 merge: start using the per-side copy dicts Martin von Zweigbergk <martinvonz@google.com> parents: 44274 diff changeset	739 branch_copies(),
fa9ad1da2e77 merge: start using the per-side copy dicts Martin von Zweigbergk <martinvonz@google.com> parents: 44274 diff changeset	740 {},
fa9ad1da2e77 merge: start using the per-side copy dicts Martin von Zweigbergk <martinvonz@google.com> parents: 44274 diff changeset	741 )
6646 9eb274d773d9 copies: teach copies about dirstate.copies Matt Mackall <mpm@selenic.com> parents: 6431 diff changeset	742
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	743 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	744 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	745 # 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	746 # 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	747 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	748
42256 a6be3af3a397 copies: ignore heuristics copytracing when using changeset-centric algos Martin von Zweigbergk <martinvonz@google.com> parents: 42255 diff changeset	749 if usechangesetcentricalgo(repo):
a6be3af3a397 copies: ignore heuristics copytracing when using changeset-centric algos Martin von Zweigbergk <martinvonz@google.com> parents: 42255 diff changeset	750 # 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	751 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	752
26013 38f92d12357c copy: add flag for disabling copy tracing Durham Goode <durham@fb.com> parents: 25924 diff changeset	753 # 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	754 # 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	755 # rebase.
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	756 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	757 # 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	758 # 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	759 # 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	760 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	761 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	762 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	763 else:
b4b196092cc3 copytrace: move the default copytracing algorithm in a new function Pulkit Goyal <7895pulkit@gmail.com> parents: 34094 diff changeset	764 return _fullcopytracing(repo, c1, c2, base)
26013 38f92d12357c copy: add flag for disabling copy tracing Durham Goode <durham@fb.com> parents: 25924 diff changeset	765
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 43022 diff changeset	766
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	767 def _isfullcopytraceable(repo, c1, base):
45957 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45907 diff changeset	768 """Checks that if base, source and destination are all no-public branches,
34367 d00910b286cd copytrace: use ctx.mutable() instead of adhoc constant of non-public phases Yuya Nishihara <yuya@tcha.org> parents: 34355 diff changeset	769 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	770 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	771
e79b3611223b copies: add docs for config `experimental.copytrace.sourcecommitlimit` Pulkit Goyal <7895pulkit@gmail.com> parents: 34367 diff changeset	772 `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	773 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	774 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	775 """
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	776 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	777 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	778 if c1.mutable() and base.mutable():
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 43022 diff changeset	779 sourcecommitlimit = repo.ui.configint(
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	780 b'experimental', b'copytrace.sourcecommitlimit'
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 43022 diff changeset	781 )
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	782 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	783 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	784 return False
fc3b8483c6cb copytrace: use the full copytracing method if only drafts are involved Pulkit Goyal <7895pulkit@gmail.com> parents: 34191 diff changeset	785
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 43022 diff changeset	786
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 43022 diff changeset	787 def _checksinglesidecopies(
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 43022 diff changeset	788 src, dsts1, m1, m2, mb, c2, base, copy, renamedelete
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 43022 diff changeset	789 ):
42252 57203e0210f8 copies: calculate mergecopies() based on pathcopies() Martin von Zweigbergk <martinvonz@google.com> parents: 42243 diff changeset	790 if src not in m2:
57203e0210f8 copies: calculate mergecopies() based on pathcopies() Martin von Zweigbergk <martinvonz@google.com> parents: 42243 diff changeset	791 # deleted on side 2
57203e0210f8 copies: calculate mergecopies() based on pathcopies() Martin von Zweigbergk <martinvonz@google.com> parents: 42243 diff changeset	792 if src not in m1:
57203e0210f8 copies: calculate mergecopies() based on pathcopies() Martin von Zweigbergk <martinvonz@google.com> parents: 42243 diff changeset	793 # 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	794 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	795 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	796 # 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	797 # 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	798 # 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	799 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	800 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	801 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	802 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	803 # modified on side 2
57203e0210f8 copies: calculate mergecopies() based on pathcopies() Martin von Zweigbergk <martinvonz@google.com> parents: 42243 diff changeset	804 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	805 copy[dst] = src
42252 57203e0210f8 copies: calculate mergecopies() based on pathcopies() Martin von Zweigbergk <martinvonz@google.com> parents: 42243 diff changeset	806
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 43022 diff changeset	807
44274 7f8bdee0034e copies: define a type to return from mergecopies() Martin von Zweigbergk <martinvonz@google.com> parents: 44272 diff changeset	808 class branch_copies(object):
7f8bdee0034e copies: define a type to return from mergecopies() Martin von Zweigbergk <martinvonz@google.com> parents: 44272 diff changeset	809 """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	810
7f8bdee0034e copies: define a type to return from mergecopies() Martin von Zweigbergk <martinvonz@google.com> parents: 44272 diff changeset	811 "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	812 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	813
7f8bdee0034e copies: define a type to return from mergecopies() Martin von Zweigbergk <martinvonz@google.com> parents: 44272 diff changeset	814 "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	815 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	816 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	817 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	818
7f8bdee0034e copies: define a type to return from mergecopies() Martin von Zweigbergk <martinvonz@google.com> parents: 44272 diff changeset	819 "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	820 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	821
7f8bdee0034e copies: define a type to return from mergecopies() Martin von Zweigbergk <martinvonz@google.com> parents: 44272 diff changeset	822 "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	823 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	824 renamed directories.
7f8bdee0034e copies: define a type to return from mergecopies() Martin von Zweigbergk <martinvonz@google.com> parents: 44272 diff changeset	825 """
7f8bdee0034e copies: define a type to return from mergecopies() Martin von Zweigbergk <martinvonz@google.com> parents: 44272 diff changeset	826
7f8bdee0034e copies: define a type to return from mergecopies() Martin von Zweigbergk <martinvonz@google.com> parents: 44272 diff changeset	827 def __init__(
7f8bdee0034e copies: define a type to return from mergecopies() Martin von Zweigbergk <martinvonz@google.com> parents: 44272 diff changeset	828 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	829 ):
7f8bdee0034e copies: define a type to return from mergecopies() Martin von Zweigbergk <martinvonz@google.com> parents: 44272 diff changeset	830 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	831 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	832 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	833 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	834
45014 cfd06649a1b8 copies: implement __repr__ on branch_copies for debugging Martin von Zweigbergk <martinvonz@google.com> parents: 44981 diff changeset	835 def __repr__(self):
45957 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45907 diff changeset	836 return '<branch_copies\n copy=%r\n renamedelete=%r\n dirmove=%r\n movewithdir=%r\n>' % (
89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45907 diff changeset	837 self.copy,
89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45907 diff changeset	838 self.renamedelete,
89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45907 diff changeset	839 self.dirmove,
89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45907 diff changeset	840 self.movewithdir,
45014 cfd06649a1b8 copies: implement __repr__ on branch_copies for debugging Martin von Zweigbergk <martinvonz@google.com> parents: 44981 diff changeset	841 )
cfd06649a1b8 copies: implement __repr__ on branch_copies for debugging Martin von Zweigbergk <martinvonz@google.com> parents: 44981 diff changeset	842
44274 7f8bdee0034e copies: define a type to return from mergecopies() Martin von Zweigbergk <martinvonz@google.com> parents: 44272 diff changeset	843
34095 b4b196092cc3 copytrace: move the default copytracing algorithm in a new function Pulkit Goyal <7895pulkit@gmail.com> parents: 34094 diff changeset	844 def _fullcopytracing(repo, c1, c2, base):
45957 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45907 diff changeset	845 """The full copytracing algorithm which finds all the new files that were
34095 b4b196092cc3 copytrace: move the default copytracing algorithm in a new function Pulkit Goyal <7895pulkit@gmail.com> parents: 34094 diff changeset	846 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	847 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	848
b4b196092cc3 copytrace: move the default copytracing algorithm in a new function Pulkit Goyal <7895pulkit@gmail.com> parents: 34094 diff changeset	849 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	850 the copies.
b4b196092cc3 copytrace: move the default copytracing algorithm in a new function Pulkit Goyal <7895pulkit@gmail.com> parents: 34094 diff changeset	851 """
6274 f3f383efbeae copies: move findcopies code to its own module Matt Mackall <mpm@selenic.com> parents: diff changeset	852 m1 = c1.manifest()
f3f383efbeae copies: move findcopies code to its own module Matt Mackall <mpm@selenic.com> parents: diff changeset	853 m2 = c2.manifest()
30186 f7ed5af31242 mergecopies: rename 'ca' to 'base' Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 30185 diff changeset	854 mb = base.manifest()
6274 f3f383efbeae copies: move findcopies code to its own module Matt Mackall <mpm@selenic.com> parents: diff changeset	855
42252 57203e0210f8 copies: calculate mergecopies() based on pathcopies() Martin von Zweigbergk <martinvonz@google.com> parents: 42243 diff changeset	856 copies1 = pathcopies(base, c1)
57203e0210f8 copies: calculate mergecopies() based on pathcopies() Martin von Zweigbergk <martinvonz@google.com> parents: 42243 diff changeset	857 copies2 = pathcopies(base, c2)
57203e0210f8 copies: calculate mergecopies() based on pathcopies() Martin von Zweigbergk <martinvonz@google.com> parents: 42243 diff changeset	858
44242 baf3fe2977cc copies: move early return in mergecopies() earlier Martin von Zweigbergk <martinvonz@google.com> parents: 44093 diff changeset	859 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	860 return branch_copies(), branch_copies(), {}
44242 baf3fe2977cc copies: move early return in mergecopies() earlier Martin von Zweigbergk <martinvonz@google.com> parents: 44093 diff changeset	861
42252 57203e0210f8 copies: calculate mergecopies() based on pathcopies() Martin von Zweigbergk <martinvonz@google.com> parents: 42243 diff changeset	862 inversecopies1 = {}
57203e0210f8 copies: calculate mergecopies() based on pathcopies() Martin von Zweigbergk <martinvonz@google.com> parents: 42243 diff changeset	863 inversecopies2 = {}
57203e0210f8 copies: calculate mergecopies() based on pathcopies() Martin von Zweigbergk <martinvonz@google.com> parents: 42243 diff changeset	864 for dst, src in copies1.items():
57203e0210f8 copies: calculate mergecopies() based on pathcopies() Martin von Zweigbergk <martinvonz@google.com> parents: 42243 diff changeset	865 inversecopies1.setdefault(src, []).append(dst)
57203e0210f8 copies: calculate mergecopies() based on pathcopies() Martin von Zweigbergk <martinvonz@google.com> parents: 42243 diff changeset	866 for dst, src in copies2.items():
57203e0210f8 copies: calculate mergecopies() based on pathcopies() Martin von Zweigbergk <martinvonz@google.com> parents: 42243 diff changeset	867 inversecopies2.setdefault(src, []).append(dst)
57203e0210f8 copies: calculate mergecopies() based on pathcopies() Martin von Zweigbergk <martinvonz@google.com> parents: 42243 diff changeset	868
44271 6ca9f45b32b0 copies: make mergecopies() distinguish between copies on each side Martin von Zweigbergk <martinvonz@google.com> parents: 44244 diff changeset	869 copy1 = {}
6ca9f45b32b0 copies: make mergecopies() distinguish between copies on each side Martin von Zweigbergk <martinvonz@google.com> parents: 44244 diff changeset	870 copy2 = {}
42252 57203e0210f8 copies: calculate mergecopies() based on pathcopies() Martin von Zweigbergk <martinvonz@google.com> parents: 42243 diff changeset	871 diverge = {}
44271 6ca9f45b32b0 copies: make mergecopies() distinguish between copies on each side Martin von Zweigbergk <martinvonz@google.com> parents: 44244 diff changeset	872 renamedelete1 = {}
6ca9f45b32b0 copies: make mergecopies() distinguish between copies on each side Martin von Zweigbergk <martinvonz@google.com> parents: 44244 diff changeset	873 renamedelete2 = {}
42252 57203e0210f8 copies: calculate mergecopies() based on pathcopies() Martin von Zweigbergk <martinvonz@google.com> parents: 42243 diff changeset	874 allsources = set(inversecopies1) \| set(inversecopies2)
57203e0210f8 copies: calculate mergecopies() based on pathcopies() Martin von Zweigbergk <martinvonz@google.com> parents: 42243 diff changeset	875 for src in allsources:
57203e0210f8 copies: calculate mergecopies() based on pathcopies() Martin von Zweigbergk <martinvonz@google.com> parents: 42243 diff changeset	876 dsts1 = inversecopies1.get(src)
57203e0210f8 copies: calculate mergecopies() based on pathcopies() Martin von Zweigbergk <martinvonz@google.com> parents: 42243 diff changeset	877 dsts2 = inversecopies2.get(src)
57203e0210f8 copies: calculate mergecopies() based on pathcopies() Martin von Zweigbergk <martinvonz@google.com> parents: 42243 diff changeset	878 if dsts1 and dsts2:
57203e0210f8 copies: calculate mergecopies() based on pathcopies() Martin von Zweigbergk <martinvonz@google.com> parents: 42243 diff changeset	879 # copied/renamed on both sides
57203e0210f8 copies: calculate mergecopies() based on pathcopies() Martin von Zweigbergk <martinvonz@google.com> parents: 42243 diff changeset	880 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	881 # renamed on both sides
57203e0210f8 copies: calculate mergecopies() based on pathcopies() Martin von Zweigbergk <martinvonz@google.com> parents: 42243 diff changeset	882 dsts1 = set(dsts1)
57203e0210f8 copies: calculate mergecopies() based on pathcopies() Martin von Zweigbergk <martinvonz@google.com> parents: 42243 diff changeset	883 dsts2 = set(dsts2)
57203e0210f8 copies: calculate mergecopies() based on pathcopies() Martin von Zweigbergk <martinvonz@google.com> parents: 42243 diff changeset	884 # 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	885 # 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	886 # 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	887 # and 'd' and deletes 'a'.
57203e0210f8 copies: calculate mergecopies() based on pathcopies() Martin von Zweigbergk <martinvonz@google.com> parents: 42243 diff changeset	888 if dsts1 & dsts2:
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 43022 diff changeset	889 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	890 copy1[dst] = src
6ca9f45b32b0 copies: make mergecopies() distinguish between copies on each side Martin von Zweigbergk <martinvonz@google.com> parents: 44244 diff changeset	891 copy2[dst] = src
42252 57203e0210f8 copies: calculate mergecopies() based on pathcopies() Martin von Zweigbergk <martinvonz@google.com> parents: 42243 diff changeset	892 else:
57203e0210f8 copies: calculate mergecopies() based on pathcopies() Martin von Zweigbergk <martinvonz@google.com> parents: 42243 diff changeset	893 diverge[src] = sorted(dsts1 \| dsts2)
57203e0210f8 copies: calculate mergecopies() based on pathcopies() Martin von Zweigbergk <martinvonz@google.com> parents: 42243 diff changeset	894 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	895 # copied on both sides
57203e0210f8 copies: calculate mergecopies() based on pathcopies() Martin von Zweigbergk <martinvonz@google.com> parents: 42243 diff changeset	896 dsts1 = set(dsts1)
57203e0210f8 copies: calculate mergecopies() based on pathcopies() Martin von Zweigbergk <martinvonz@google.com> parents: 42243 diff changeset	897 dsts2 = set(dsts2)
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 43022 diff changeset	898 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	899 copy1[dst] = src
6ca9f45b32b0 copies: make mergecopies() distinguish between copies on each side Martin von Zweigbergk <martinvonz@google.com> parents: 44244 diff changeset	900 copy2[dst] = src
42252 57203e0210f8 copies: calculate mergecopies() based on pathcopies() Martin von Zweigbergk <martinvonz@google.com> parents: 42243 diff changeset	901 # 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	902 # on the other side
57203e0210f8 copies: calculate mergecopies() based on pathcopies() Martin von Zweigbergk <martinvonz@google.com> parents: 42243 diff changeset	903 elif dsts1:
57203e0210f8 copies: calculate mergecopies() based on pathcopies() Martin von Zweigbergk <martinvonz@google.com> parents: 42243 diff changeset	904 # copied/renamed only on side 1
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 43022 diff changeset	905 _checksinglesidecopies(
44271 6ca9f45b32b0 copies: make mergecopies() distinguish between copies on each side Martin von Zweigbergk <martinvonz@google.com> parents: 44244 diff changeset	906 src, dsts1, m1, m2, mb, c2, base, copy1, renamedelete1
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 43022 diff changeset	907 )
42252 57203e0210f8 copies: calculate mergecopies() based on pathcopies() Martin von Zweigbergk <martinvonz@google.com> parents: 42243 diff changeset	908 elif dsts2:
57203e0210f8 copies: calculate mergecopies() based on pathcopies() Martin von Zweigbergk <martinvonz@google.com> parents: 42243 diff changeset	909 # copied/renamed only on side 2
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 43022 diff changeset	910 _checksinglesidecopies(
44271 6ca9f45b32b0 copies: make mergecopies() distinguish between copies on each side Martin von Zweigbergk <martinvonz@google.com> parents: 44244 diff changeset	911 src, dsts2, m2, m1, mb, c1, base, copy2, renamedelete2
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 43022 diff changeset	912 )
42252 57203e0210f8 copies: calculate mergecopies() based on pathcopies() Martin von Zweigbergk <martinvonz@google.com> parents: 42243 diff changeset	913
26659 df66736a128e copies: group bothnew with other sets Matt Mackall <mpm@selenic.com> parents: 26658 diff changeset	914 # find interesting file sets from manifests
46110 2f357d053df2 copies: make calculating lazy for dir move detection's "addedfiles" Kyle Lippincott <spectral@google.com> parents: 46061 diff changeset	915 cache = []
2f357d053df2 copies: make calculating lazy for dir move detection's "addedfiles" Kyle Lippincott <spectral@google.com> parents: 46061 diff changeset	916
2f357d053df2 copies: make calculating lazy for dir move detection's "addedfiles" Kyle Lippincott <spectral@google.com> parents: 46061 diff changeset	917 def _get_addedfiles(idx):
2f357d053df2 copies: make calculating lazy for dir move detection's "addedfiles" Kyle Lippincott <spectral@google.com> parents: 46061 diff changeset	918 if not cache:
2f357d053df2 copies: make calculating lazy for dir move detection's "addedfiles" Kyle Lippincott <spectral@google.com> parents: 46061 diff changeset	919 addedinm1 = m1.filesnotin(mb, repo.narrowmatch())
2f357d053df2 copies: make calculating lazy for dir move detection's "addedfiles" Kyle Lippincott <spectral@google.com> parents: 46061 diff changeset	920 addedinm2 = m2.filesnotin(mb, repo.narrowmatch())
2f357d053df2 copies: make calculating lazy for dir move detection's "addedfiles" Kyle Lippincott <spectral@google.com> parents: 46061 diff changeset	921 u1 = sorted(addedinm1 - addedinm2)
2f357d053df2 copies: make calculating lazy for dir move detection's "addedfiles" Kyle Lippincott <spectral@google.com> parents: 46061 diff changeset	922 u2 = sorted(addedinm2 - addedinm1)
2f357d053df2 copies: make calculating lazy for dir move detection's "addedfiles" Kyle Lippincott <spectral@google.com> parents: 46061 diff changeset	923 cache.extend((u1, u2))
2f357d053df2 copies: make calculating lazy for dir move detection's "addedfiles" Kyle Lippincott <spectral@google.com> parents: 46061 diff changeset	924 return cache[idx]
42253 d69bc8ffbe6f copies: inline _computenonoverlap() in mergecopies() Martin von Zweigbergk <martinvonz@google.com> parents: 42252 diff changeset	925
46110 2f357d053df2 copies: make calculating lazy for dir move detection's "addedfiles" Kyle Lippincott <spectral@google.com> parents: 46061 diff changeset	926 u1fn = lambda: _get_addedfiles(0)
2f357d053df2 copies: make calculating lazy for dir move detection's "addedfiles" Kyle Lippincott <spectral@google.com> parents: 46061 diff changeset	927 u2fn = lambda: _get_addedfiles(1)
2f357d053df2 copies: make calculating lazy for dir move detection's "addedfiles" Kyle Lippincott <spectral@google.com> parents: 46061 diff changeset	928 if repo.ui.debugflag:
2f357d053df2 copies: make calculating lazy for dir move detection's "addedfiles" Kyle Lippincott <spectral@google.com> parents: 46061 diff changeset	929 u1 = u1fn()
2f357d053df2 copies: make calculating lazy for dir move detection's "addedfiles" Kyle Lippincott <spectral@google.com> parents: 46061 diff changeset	930 u2 = u2fn()
6274 f3f383efbeae copies: move findcopies code to its own module Matt Mackall <mpm@selenic.com> parents: diff changeset	931
46110 2f357d053df2 copies: make calculating lazy for dir move detection's "addedfiles" Kyle Lippincott <spectral@google.com> parents: 46061 diff changeset	932 header = b" unmatched files in %s"
2f357d053df2 copies: make calculating lazy for dir move detection's "addedfiles" Kyle Lippincott <spectral@google.com> parents: 46061 diff changeset	933 if u1:
2f357d053df2 copies: make calculating lazy for dir move detection's "addedfiles" Kyle Lippincott <spectral@google.com> parents: 46061 diff changeset	934 repo.ui.debug(
2f357d053df2 copies: make calculating lazy for dir move detection's "addedfiles" Kyle Lippincott <spectral@google.com> parents: 46061 diff changeset	935 b"%s:\n %s\n" % (header % b'local', b"\n ".join(u1))
2f357d053df2 copies: make calculating lazy for dir move detection's "addedfiles" Kyle Lippincott <spectral@google.com> parents: 46061 diff changeset	936 )
2f357d053df2 copies: make calculating lazy for dir move detection's "addedfiles" Kyle Lippincott <spectral@google.com> parents: 46061 diff changeset	937 if u2:
2f357d053df2 copies: make calculating lazy for dir move detection's "addedfiles" Kyle Lippincott <spectral@google.com> parents: 46061 diff changeset	938 repo.ui.debug(
2f357d053df2 copies: make calculating lazy for dir move detection's "addedfiles" Kyle Lippincott <spectral@google.com> parents: 46061 diff changeset	939 b"%s:\n %s\n" % (header % b'other', b"\n ".join(u2))
2f357d053df2 copies: make calculating lazy for dir move detection's "addedfiles" Kyle Lippincott <spectral@google.com> parents: 46061 diff changeset	940 )
2f357d053df2 copies: make calculating lazy for dir move detection's "addedfiles" Kyle Lippincott <spectral@google.com> parents: 46061 diff changeset	941
44243 782e0d9c3b74 copies: avoid calculating debug-only stuff without --debug Martin von Zweigbergk <martinvonz@google.com> parents: 44242 diff changeset	942 renamedeleteset = set()
782e0d9c3b74 copies: avoid calculating debug-only stuff without --debug Martin von Zweigbergk <martinvonz@google.com> parents: 44242 diff changeset	943 divergeset = set()
782e0d9c3b74 copies: avoid calculating debug-only stuff without --debug Martin von Zweigbergk <martinvonz@google.com> parents: 44242 diff changeset	944 for dsts in diverge.values():
782e0d9c3b74 copies: avoid calculating debug-only stuff without --debug Martin von Zweigbergk <martinvonz@google.com> parents: 44242 diff changeset	945 divergeset.update(dsts)
44271 6ca9f45b32b0 copies: make mergecopies() distinguish between copies on each side Martin von Zweigbergk <martinvonz@google.com> parents: 44244 diff changeset	946 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	947 renamedeleteset.update(dsts)
6ca9f45b32b0 copies: make mergecopies() distinguish between copies on each side Martin von Zweigbergk <martinvonz@google.com> parents: 44244 diff changeset	948 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	949 renamedeleteset.update(dsts)
782e0d9c3b74 copies: avoid calculating debug-only stuff without --debug Martin von Zweigbergk <martinvonz@google.com> parents: 44242 diff changeset	950
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 43022 diff changeset	951 repo.ui.debug(
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	952 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	953 b"% = renamed and deleted):\n"
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 43022 diff changeset	954 )
44272 17e12938f8e7 copies: print debug information about copies per side/branch Martin von Zweigbergk <martinvonz@google.com> parents: 44271 diff changeset	955 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	956 if not copies:
17e12938f8e7 copies: print debug information about copies per side/branch Martin von Zweigbergk <martinvonz@google.com> parents: 44271 diff changeset	957 continue
17e12938f8e7 copies: print debug information about copies per side/branch Martin von Zweigbergk <martinvonz@google.com> parents: 44271 diff changeset	958 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	959 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	960 note = b""
17e12938f8e7 copies: print debug information about copies per side/branch Martin von Zweigbergk <martinvonz@google.com> parents: 44271 diff changeset	961 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	962 note += b"*"
17e12938f8e7 copies: print debug information about copies per side/branch Martin von Zweigbergk <martinvonz@google.com> parents: 44271 diff changeset	963 if f in divergeset:
17e12938f8e7 copies: print debug information about copies per side/branch Martin von Zweigbergk <martinvonz@google.com> parents: 44271 diff changeset	964 note += b"!"
17e12938f8e7 copies: print debug information about copies per side/branch Martin von Zweigbergk <martinvonz@google.com> parents: 44271 diff changeset	965 if f in renamedeleteset:
17e12938f8e7 copies: print debug information about copies per side/branch Martin von Zweigbergk <martinvonz@google.com> parents: 44271 diff changeset	966 note += b"%"
17e12938f8e7 copies: print debug information about copies per side/branch Martin von Zweigbergk <martinvonz@google.com> parents: 44271 diff changeset	967 repo.ui.debug(
17e12938f8e7 copies: print debug information about copies per side/branch Martin von Zweigbergk <martinvonz@google.com> parents: 44271 diff changeset	968 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	969 )
44243 782e0d9c3b74 copies: avoid calculating debug-only stuff without --debug Martin von Zweigbergk <martinvonz@google.com> parents: 44242 diff changeset	970 del renamedeleteset
782e0d9c3b74 copies: avoid calculating debug-only stuff without --debug Martin von Zweigbergk <martinvonz@google.com> parents: 44242 diff changeset	971 del divergeset
6274 f3f383efbeae copies: move findcopies code to its own module Matt Mackall <mpm@selenic.com> parents: diff changeset	972
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	973 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	974
46110 2f357d053df2 copies: make calculating lazy for dir move detection's "addedfiles" Kyle Lippincott <spectral@google.com> parents: 46061 diff changeset	975 dirmove1, movewithdir2 = _dir_renames(repo, c1, copy1, copies1, u2fn)
2f357d053df2 copies: make calculating lazy for dir move detection's "addedfiles" Kyle Lippincott <spectral@google.com> parents: 46061 diff changeset	976 dirmove2, movewithdir1 = _dir_renames(repo, c2, copy2, copies2, u1fn)
44244 45192589555c copies: extract function for finding directory renames Martin von Zweigbergk <martinvonz@google.com> parents: 44243 diff changeset	977
44275 fa9ad1da2e77 merge: start using the per-side copy dicts Martin von Zweigbergk <martinvonz@google.com> parents: 44274 diff changeset	978 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	979 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	980
44275 fa9ad1da2e77 merge: start using the per-side copy dicts Martin von Zweigbergk <martinvonz@google.com> parents: 44274 diff changeset	981 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	982
45192589555c copies: extract function for finding directory renames Martin von Zweigbergk <martinvonz@google.com> parents: 44243 diff changeset	983
46110 2f357d053df2 copies: make calculating lazy for dir move detection's "addedfiles" Kyle Lippincott <spectral@google.com> parents: 46061 diff changeset	984 def _dir_renames(repo, ctx, copy, fullcopy, addedfilesfn):
44271 6ca9f45b32b0 copies: make mergecopies() distinguish between copies on each side Martin von Zweigbergk <martinvonz@google.com> parents: 44244 diff changeset	985 """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	986
6ca9f45b32b0 copies: make mergecopies() distinguish between copies on each side Martin von Zweigbergk <martinvonz@google.com> parents: 44244 diff changeset	987 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	988 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	989 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	990 merge.manifestmerge() won't care about
46110 2f357d053df2 copies: make calculating lazy for dir move detection's "addedfiles" Kyle Lippincott <spectral@google.com> parents: 46061 diff changeset	991 addedfilesfn: function returning added files on the other side (compared to
2f357d053df2 copies: make calculating lazy for dir move detection's "addedfiles" Kyle Lippincott <spectral@google.com> parents: 46061 diff changeset	992 ctx)
44271 6ca9f45b32b0 copies: make mergecopies() distinguish between copies on each side Martin von Zweigbergk <martinvonz@google.com> parents: 44244 diff changeset	993 """
6274 f3f383efbeae copies: move findcopies code to its own module Matt Mackall <mpm@selenic.com> parents: diff changeset	994 # generate a directory move map
17055 8b7cd9a998f0 copies: re-include root directory in directory rename detection (issue3511) Matt Mackall <mpm@selenic.com> parents: 16795 diff changeset	995 invalid = set()
6274 f3f383efbeae copies: move findcopies code to its own module Matt Mackall <mpm@selenic.com> parents: diff changeset	996 dirmove = {}
f3f383efbeae copies: move findcopies code to its own module Matt Mackall <mpm@selenic.com> parents: diff changeset	997
f3f383efbeae copies: move findcopies code to its own module Matt Mackall <mpm@selenic.com> parents: diff changeset	998 # 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	999 # 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	1000 for dst, src in pycompat.iteritems(fullcopy):
25282 0f28815ef066 copies: switch to using pathutil.dirname Durham Goode <durham@fb.com> parents: 24782 diff changeset	1001 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	1002 if dsrc in invalid:
f3f383efbeae copies: move findcopies code to its own module Matt Mackall <mpm@selenic.com> parents: diff changeset	1003 # already seen to be uninteresting
f3f383efbeae copies: move findcopies code to its own module Matt Mackall <mpm@selenic.com> parents: diff changeset	1004 continue
46026 b9588ff9b66a copies: avoid materializing a full directory map during copy tracing Kyle Lippincott <spectral@google.com> parents: 46001 diff changeset	1005 elif ctx.hasdir(dsrc) and ctx.hasdir(ddst):
6274 f3f383efbeae copies: move findcopies code to its own module Matt Mackall <mpm@selenic.com> parents: diff changeset	1006 # 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	1007 invalid.add(dsrc)
eebd591803ab copies: correctly skip directories that have already been considered Kyle Lippincott <spectral@google.com> parents: 38670 diff changeset	1008 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	1009 # 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	1010 invalid.add(dsrc)
6274 f3f383efbeae copies: move findcopies code to its own module Matt Mackall <mpm@selenic.com> parents: diff changeset	1011 else:
f3f383efbeae copies: move findcopies code to its own module Matt Mackall <mpm@selenic.com> parents: diff changeset	1012 # looks good so far
39291 eebd591803ab copies: correctly skip directories that have already been considered Kyle Lippincott <spectral@google.com> parents: 38670 diff changeset	1013 dirmove[dsrc] = ddst
6274 f3f383efbeae copies: move findcopies code to its own module Matt Mackall <mpm@selenic.com> parents: diff changeset	1014
f3f383efbeae copies: move findcopies code to its own module Matt Mackall <mpm@selenic.com> parents: diff changeset	1015 for i in invalid:
f3f383efbeae copies: move findcopies code to its own module Matt Mackall <mpm@selenic.com> parents: diff changeset	1016 if i in dirmove:
f3f383efbeae copies: move findcopies code to its own module Matt Mackall <mpm@selenic.com> parents: diff changeset	1017 del dirmove[i]
46026 b9588ff9b66a copies: avoid materializing a full directory map during copy tracing Kyle Lippincott <spectral@google.com> parents: 46001 diff changeset	1018 del invalid
6274 f3f383efbeae copies: move findcopies code to its own module Matt Mackall <mpm@selenic.com> parents: diff changeset	1019
f3f383efbeae copies: move findcopies code to its own module Matt Mackall <mpm@selenic.com> parents: diff changeset	1020 if not dirmove:
44244 45192589555c copies: extract function for finding directory renames Martin von Zweigbergk <martinvonz@google.com> parents: 44243 diff changeset	1021 return {}, {}
6274 f3f383efbeae copies: move findcopies code to its own module Matt Mackall <mpm@selenic.com> parents: diff changeset	1022
43106 d783f945a701 py3: finish porting iteritems() to pycompat and remove source transformer Gregory Szorc <gregory.szorc@gmail.com> parents: 43077 diff changeset	1023 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	1024
6274 f3f383efbeae copies: move findcopies code to its own module Matt Mackall <mpm@selenic.com> parents: diff changeset	1025 for d in dirmove:
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 43022 diff changeset	1026 repo.ui.debug(
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1027 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	1028 )
6274 f3f383efbeae copies: move findcopies code to its own module Matt Mackall <mpm@selenic.com> parents: diff changeset	1029
30183 0106f93ca1d5 checkcopies: move 'movewithdir' initialisation right before its usage Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 30138 diff changeset	1030 movewithdir = {}
6274 f3f383efbeae copies: move findcopies code to its own module Matt Mackall <mpm@selenic.com> parents: diff changeset	1031 # check unaccounted nonoverlapping files against directory moves
46110 2f357d053df2 copies: make calculating lazy for dir move detection's "addedfiles" Kyle Lippincott <spectral@google.com> parents: 46061 diff changeset	1032 for f in addedfilesfn():
6274 f3f383efbeae copies: move findcopies code to its own module Matt Mackall <mpm@selenic.com> parents: diff changeset	1033 if f not in fullcopy:
f3f383efbeae copies: move findcopies code to its own module Matt Mackall <mpm@selenic.com> parents: diff changeset	1034 for d in dirmove:
f3f383efbeae copies: move findcopies code to its own module Matt Mackall <mpm@selenic.com> parents: diff changeset	1035 if f.startswith(d):
f3f383efbeae copies: move findcopies code to its own module Matt Mackall <mpm@selenic.com> parents: diff changeset	1036 # 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	1037 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	1038 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	1039 movewithdir[f] = df
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 43022 diff changeset	1040 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	1041 b" pending file src: '%s' -> dst: '%s'\n"
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 43022 diff changeset	1042 % (f, df)
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 43022 diff changeset	1043 )
6274 f3f383efbeae copies: move findcopies code to its own module Matt Mackall <mpm@selenic.com> parents: diff changeset	1044 break
f3f383efbeae copies: move findcopies code to its own module Matt Mackall <mpm@selenic.com> parents: diff changeset	1045
44244 45192589555c copies: extract function for finding directory renames Martin von Zweigbergk <martinvonz@google.com> parents: 44243 diff changeset	1046 return dirmove, movewithdir
19178 4327687ca757 copies: refactor checkcopies() into a top level method Durham Goode <durham@fb.com> parents: 18899 diff changeset	1047
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 43022 diff changeset	1048
34191 036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core Pulkit Goyal <7895pulkit@gmail.com> parents: 34095 diff changeset	1049 def _heuristicscopytracing(repo, c1, c2, base):
45957 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45907 diff changeset	1050 """Fast copytracing using filename heuristics
34191 036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core Pulkit Goyal <7895pulkit@gmail.com> parents: 34095 diff changeset	1051
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core Pulkit Goyal <7895pulkit@gmail.com> parents: 34095 diff changeset	1052 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	1053
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core Pulkit Goyal <7895pulkit@gmail.com> parents: 34095 diff changeset	1054 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	1055 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	1056 (same filenames but different directory names)
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core Pulkit Goyal <7895pulkit@gmail.com> parents: 34095 diff changeset	1057
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core Pulkit Goyal <7895pulkit@gmail.com> parents: 34095 diff changeset	1058 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	1059 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	1060
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core Pulkit Goyal <7895pulkit@gmail.com> parents: 34095 diff changeset	1061 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	1062
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core Pulkit Goyal <7895pulkit@gmail.com> parents: 34095 diff changeset	1063 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	1064
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core Pulkit Goyal <7895pulkit@gmail.com> parents: 34095 diff changeset	1065 [experimental]
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core Pulkit Goyal <7895pulkit@gmail.com> parents: 34095 diff changeset	1066 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	1067
f05a6e015ecc copies: add a config to limit the number of candidates to check in heuristics Pulkit Goyal <7895pulkit@gmail.com> parents: 34787 diff changeset	1068 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	1069 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	1070 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	1071 `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	1072 """
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core Pulkit Goyal <7895pulkit@gmail.com> parents: 34095 diff changeset	1073
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core Pulkit Goyal <7895pulkit@gmail.com> parents: 34095 diff changeset	1074 if c1.rev() is None:
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core Pulkit Goyal <7895pulkit@gmail.com> parents: 34095 diff changeset	1075 c1 = c1.p1()
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core Pulkit Goyal <7895pulkit@gmail.com> parents: 34095 diff changeset	1076 if c2.rev() is None:
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core Pulkit Goyal <7895pulkit@gmail.com> parents: 34095 diff changeset	1077 c2 = c2.p1()
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core Pulkit Goyal <7895pulkit@gmail.com> parents: 34095 diff changeset	1078
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core Pulkit Goyal <7895pulkit@gmail.com> parents: 34095 diff changeset	1079 changedfiles = set()
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core Pulkit Goyal <7895pulkit@gmail.com> parents: 34095 diff changeset	1080 m1 = c1.manifest()
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1081 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	1082 # 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	1083 repo.ui.debug(
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1084 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	1085 b"an ancestor of c2\n"
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 43022 diff changeset	1086 )
34191 036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core Pulkit Goyal <7895pulkit@gmail.com> parents: 34095 diff changeset	1087 return _fullcopytracing(repo, c1, c2, base)
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core Pulkit Goyal <7895pulkit@gmail.com> parents: 34095 diff changeset	1088
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core Pulkit Goyal <7895pulkit@gmail.com> parents: 34095 diff changeset	1089 ctx = c2
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core Pulkit Goyal <7895pulkit@gmail.com> parents: 34095 diff changeset	1090 while ctx != base:
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core Pulkit Goyal <7895pulkit@gmail.com> parents: 34095 diff changeset	1091 if len(ctx.parents()) == 2:
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core Pulkit Goyal <7895pulkit@gmail.com> parents: 34095 diff changeset	1092 # 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	1093 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	1094 return _fullcopytracing(repo, c1, c2, base)
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core Pulkit Goyal <7895pulkit@gmail.com> parents: 34095 diff changeset	1095 changedfiles.update(ctx.files())
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core Pulkit Goyal <7895pulkit@gmail.com> parents: 34095 diff changeset	1096 ctx = ctx.p1()
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core Pulkit Goyal <7895pulkit@gmail.com> parents: 34095 diff changeset	1097
44275 fa9ad1da2e77 merge: start using the per-side copy dicts Martin von Zweigbergk <martinvonz@google.com> parents: 44274 diff changeset	1098 copies2 = {}
34191 036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core Pulkit Goyal <7895pulkit@gmail.com> parents: 34095 diff changeset	1099 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	1100 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	1101 if src in m1:
44275 fa9ad1da2e77 merge: start using the per-side copy dicts Martin von Zweigbergk <martinvonz@google.com> parents: 44274 diff changeset	1102 copies2[dst] = src
34191 036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core Pulkit Goyal <7895pulkit@gmail.com> parents: 34095 diff changeset	1103
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core Pulkit Goyal <7895pulkit@gmail.com> parents: 34095 diff changeset	1104 # 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	1105 # 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	1106 # 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	1107 # 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	1108 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	1109 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	1110
44275 fa9ad1da2e77 merge: start using the per-side copy dicts Martin von Zweigbergk <martinvonz@google.com> parents: 44274 diff changeset	1111 copies1 = {}
34191 036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core Pulkit Goyal <7895pulkit@gmail.com> parents: 34095 diff changeset	1112 if missingfiles:
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core Pulkit Goyal <7895pulkit@gmail.com> parents: 34095 diff changeset	1113 basenametofilename = collections.defaultdict(list)
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core Pulkit Goyal <7895pulkit@gmail.com> parents: 34095 diff changeset	1114 dirnametofilename = collections.defaultdict(list)
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core Pulkit Goyal <7895pulkit@gmail.com> parents: 34095 diff changeset	1115
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core Pulkit Goyal <7895pulkit@gmail.com> parents: 34095 diff changeset	1116 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	1117 basename = os.path.basename(f)
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core Pulkit Goyal <7895pulkit@gmail.com> parents: 34095 diff changeset	1118 dirname = os.path.dirname(f)
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core Pulkit Goyal <7895pulkit@gmail.com> parents: 34095 diff changeset	1119 basenametofilename[basename].append(f)
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core Pulkit Goyal <7895pulkit@gmail.com> parents: 34095 diff changeset	1120 dirnametofilename[dirname].append(f)
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core Pulkit Goyal <7895pulkit@gmail.com> parents: 34095 diff changeset	1121
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core Pulkit Goyal <7895pulkit@gmail.com> parents: 34095 diff changeset	1122 for f in missingfiles:
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core Pulkit Goyal <7895pulkit@gmail.com> parents: 34095 diff changeset	1123 basename = os.path.basename(f)
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core Pulkit Goyal <7895pulkit@gmail.com> parents: 34095 diff changeset	1124 dirname = os.path.dirname(f)
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core Pulkit Goyal <7895pulkit@gmail.com> parents: 34095 diff changeset	1125 samebasename = basenametofilename[basename]
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core Pulkit Goyal <7895pulkit@gmail.com> parents: 34095 diff changeset	1126 samedirname = dirnametofilename[dirname]
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core Pulkit Goyal <7895pulkit@gmail.com> parents: 34095 diff changeset	1127 movecandidates = samebasename + samedirname
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core Pulkit Goyal <7895pulkit@gmail.com> parents: 34095 diff changeset	1128 # 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	1129 # c2.filectx(f) won't fail
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core Pulkit Goyal <7895pulkit@gmail.com> parents: 34095 diff changeset	1130 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	1131 # 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	1132 # 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	1133 maxcandidates = repo.ui.configint(
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1134 b'experimental', b'copytrace.movecandidateslimit'
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 43022 diff changeset	1135 )
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	1136
f05a6e015ecc copies: add a config to limit the number of candidates to check in heuristics Pulkit Goyal <7895pulkit@gmail.com> parents: 34787 diff changeset	1137 if len(movecandidates) > maxcandidates:
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 43022 diff changeset	1138 repo.ui.status(
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 43022 diff changeset	1139 _(
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1140 b"skipping copytracing for '%s', more "
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1141 b"candidates than the limit: %d\n"
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 43022 diff changeset	1142 )
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 43022 diff changeset	1143 % (f, len(movecandidates))
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 43022 diff changeset	1144 )
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	1145 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	1146
34191 036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core Pulkit Goyal <7895pulkit@gmail.com> parents: 34095 diff changeset	1147 for candidate in movecandidates:
036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core Pulkit Goyal <7895pulkit@gmail.com> parents: 34095 diff changeset	1148 f1 = c1.filectx(candidate)
37392 a4f02a17420d copies: clean up _related logic G?bor Stefanik <gabor.stefanik@nng.com> parents: 36379 diff changeset	1149 if _related(f1, f2):
34191 036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core Pulkit Goyal <7895pulkit@gmail.com> parents: 34095 diff changeset	1150 # 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	1151 # 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	1152 # of upstream copytracing
44275 fa9ad1da2e77 merge: start using the per-side copy dicts Martin von Zweigbergk <martinvonz@google.com> parents: 44274 diff changeset	1153 copies1[candidate] = f
34191 036d47d7cf39 copytrace: move fast heuristic copytracing algorithm to core Pulkit Goyal <7895pulkit@gmail.com> parents: 34095 diff changeset	1154
44275 fa9ad1da2e77 merge: start using the per-side copy dicts Martin von Zweigbergk <martinvonz@google.com> parents: 44274 diff changeset	1155 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	1156
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 43022 diff changeset	1157
37392 a4f02a17420d copies: clean up _related logic G?bor Stefanik <gabor.stefanik@nng.com> parents: 36379 diff changeset	1158 def _related(f1, f2):
30138 733fb9f7bc92 checkcopies: extract the '_related' closure Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 30137 diff changeset	1159 """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	1160
733fb9f7bc92 checkcopies: extract the '_related' closure Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 30137 diff changeset	1161 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	1162 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	1163 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	1164 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	1165 """
733fb9f7bc92 checkcopies: extract the '_related' closure Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 30137 diff changeset	1166
733fb9f7bc92 checkcopies: extract the '_related' closure Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 30137 diff changeset	1167 if f1 == f2:
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 43022 diff changeset	1168 return True # a match
30138 733fb9f7bc92 checkcopies: extract the '_related' closure Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 30137 diff changeset	1169
733fb9f7bc92 checkcopies: extract the '_related' closure Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 30137 diff changeset	1170 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	1171 try:
733fb9f7bc92 checkcopies: extract the '_related' closure Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 30137 diff changeset	1172 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	1173
733fb9f7bc92 checkcopies: extract the '_related' closure Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 30137 diff changeset	1174 if f1r is None:
733fb9f7bc92 checkcopies: extract the '_related' closure Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 30137 diff changeset	1175 f1 = next(g1)
733fb9f7bc92 checkcopies: extract the '_related' closure Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 30137 diff changeset	1176 if f2r is None:
733fb9f7bc92 checkcopies: extract the '_related' closure Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 30137 diff changeset	1177 f2 = next(g2)
733fb9f7bc92 checkcopies: extract the '_related' closure Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 30137 diff changeset	1178
733fb9f7bc92 checkcopies: extract the '_related' closure Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 30137 diff changeset	1179 while True:
733fb9f7bc92 checkcopies: extract the '_related' closure Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 30137 diff changeset	1180 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	1181 if f1r > f2r:
733fb9f7bc92 checkcopies: extract the '_related' closure Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 30137 diff changeset	1182 f1 = next(g1)
733fb9f7bc92 checkcopies: extract the '_related' closure Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 30137 diff changeset	1183 elif f2r > f1r:
733fb9f7bc92 checkcopies: extract the '_related' closure Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 30137 diff changeset	1184 f2 = next(g2)
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 43022 diff changeset	1185 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	1186 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	1187 except StopIteration:
733fb9f7bc92 checkcopies: extract the '_related' closure Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 30137 diff changeset	1188 return False
733fb9f7bc92 checkcopies: extract the '_related' closure Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 30137 diff changeset	1189
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 43022 diff changeset	1190
44092 833210fbd900 graftcopies: remove `skip` and `repo` arguments Martin von Zweigbergk <martinvonz@google.com> parents: 44091 diff changeset	1191 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	1192 """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	1193
06e7e7652ac0 graftcopies: document why the function is useful at all Martin von Zweigbergk <martinvonz@google.com> parents: 44092 diff changeset	1194 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	1195 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	1196 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	1197 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	1198 (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	1199 experimental.copytrace=off.
06e7e7652ac0 graftcopies: document why the function is useful at all Martin von Zweigbergk <martinvonz@google.com> parents: 44092 diff changeset	1200
06e7e7652ac0 graftcopies: document why the function is useful at all Martin von Zweigbergk <martinvonz@google.com> parents: 44092 diff changeset	1201 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	1202 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	1203 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	1204 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	1205 by merge.update().
06e7e7652ac0 graftcopies: document why the function is useful at all Martin von Zweigbergk <martinvonz@google.com> parents: 44092 diff changeset	1206 """
44091 3df0bd706c40 graftcopies: use _filter() for filtering out invalid copies Martin von Zweigbergk <martinvonz@google.com> parents: 44090 diff changeset	1207 new_copies = pathcopies(base, ctx)
3df0bd706c40 graftcopies: use _filter() for filtering out invalid copies Martin von Zweigbergk <martinvonz@google.com> parents: 44090 diff changeset	1208 _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	1209 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	1210 wctx[dst].markcopied(src)

Mercurial > public > mercurial-scm > hg-stable

annotate mercurial/copies.py @ 46148:70a9eb899637