| hg-reviewers |
The point of this patch is mostly to clarify manifestmerge(). I find
it much easier to reason about now.
| No Linters Available |
| No Unit Test Coverage |
| Path | Packages | |||
|---|---|---|---|---|
| M | mercurial/copies.py (26 lines) | |||
| M | mercurial/merge.py (51 lines) |
| Commit | Parents | Author | Summary | Date |
|---|---|---|---|---|
| 9a8e8af4c1c7 | 5bd9001dde2c | Martin von Zweigbergk | Jan 23 2020, 6:44 PM |
| Status | Author | Revision | |
|---|---|---|---|
| Closed | martinvonz | ||
| Closed | martinvonz | ||
| Closed | martinvonz | ||
| Closed | martinvonz | ||
| Closed | martinvonz | ||
| Closed | martinvonz | ||
| Closed | martinvonz | ||
| Closed | martinvonz | ||
| Closed | martinvonz | ||
| Closed | martinvonz |
| "diverge" is a mapping of source name -> list of destination names | "diverge" is a mapping of source name -> list of destination names | ||||
| for divergent renames. | for divergent renames. | ||||
| This function calls different copytracing algorithms based on config. | This function calls different copytracing algorithms based on config. | ||||
| """ | """ | ||||
| # avoid silly behavior for update from empty dir | # avoid silly behavior for update from empty dir | ||||
| if not c1 or not c2 or c1 == c2: | if not c1 or not c2 or c1 == c2: | ||||
| return branch_copies(), {} | return branch_copies(), branch_copies(), {} | ||||
| narrowmatch = c1.repo().narrowmatch() | narrowmatch = c1.repo().narrowmatch() | ||||
| # avoid silly behavior for parent -> working dir | # avoid silly behavior for parent -> working dir | ||||
| if c2.node() is None and c1.node() == repo.dirstate.p1(): | if c2.node() is None and c1.node() == repo.dirstate.p1(): | ||||
| return branch_copies(_dirstatecopies(repo, narrowmatch)), {} | return branch_copies(_dirstatecopies(repo, narrowmatch)), branch_copies(), {} | ||||
| copytracing = repo.ui.config(b'experimental', b'copytrace') | copytracing = repo.ui.config(b'experimental', b'copytrace') | ||||
| if stringutil.parsebool(copytracing) is False: | if stringutil.parsebool(copytracing) is False: | ||||
| # stringutil.parsebool() returns None when it is unable to parse the | # stringutil.parsebool() returns None when it is unable to parse the | ||||
| # value, so we should rely on making sure copytracing is on such cases | # value, so we should rely on making sure copytracing is on such cases | ||||
| return branch_copies(), {} | return branch_copies(), branch_copies(), {} | ||||
| if usechangesetcentricalgo(repo): | if usechangesetcentricalgo(repo): | ||||
| # The heuristics don't make sense when we need changeset-centric algos | # The heuristics don't make sense when we need changeset-centric algos | ||||
| return _fullcopytracing(repo, c1, c2, base) | return _fullcopytracing(repo, c1, c2, base) | ||||
| # Copy trace disabling is explicitly below the node == p1 logic above | # Copy trace disabling is explicitly below the node == p1 logic above | ||||
| # because the logic above is required for a simple copy to be kept across a | # because the logic above is required for a simple copy to be kept across a | ||||
| # rebase. | # rebase. | ||||
| m1 = c1.manifest() | m1 = c1.manifest() | ||||
| m2 = c2.manifest() | m2 = c2.manifest() | ||||
| mb = base.manifest() | mb = base.manifest() | ||||
| copies1 = pathcopies(base, c1) | copies1 = pathcopies(base, c1) | ||||
| copies2 = pathcopies(base, c2) | copies2 = pathcopies(base, c2) | ||||
| if not (copies1 or copies2): | if not (copies1 or copies2): | ||||
| return branch_copies(), {} | return branch_copies(), branch_copies(), {} | ||||
| inversecopies1 = {} | inversecopies1 = {} | ||||
| inversecopies2 = {} | inversecopies2 = {} | ||||
| for dst, src in copies1.items(): | for dst, src in copies1.items(): | ||||
| inversecopies1.setdefault(src, []).append(dst) | inversecopies1.setdefault(src, []).append(dst) | ||||
| for dst, src in copies2.items(): | for dst, src in copies2.items(): | ||||
| inversecopies2.setdefault(src, []).append(dst) | inversecopies2.setdefault(src, []).append(dst) | ||||
| del renamedeleteset | del renamedeleteset | ||||
| del divergeset | del divergeset | ||||
| repo.ui.debug(b" checking for directory renames\n") | repo.ui.debug(b" checking for directory renames\n") | ||||
| dirmove1, movewithdir2 = _dir_renames(repo, c1, copy1, copies1, u2) | dirmove1, movewithdir2 = _dir_renames(repo, c1, copy1, copies1, u2) | ||||
| dirmove2, movewithdir1 = _dir_renames(repo, c2, copy2, copies2, u1) | dirmove2, movewithdir1 = _dir_renames(repo, c2, copy2, copies2, u1) | ||||
| copy1.update(copy2) | branch_copies1 = branch_copies(copy1, renamedelete1, dirmove1, movewithdir1) | ||||
| renamedelete1.update(renamedelete2) | branch_copies2 = branch_copies(copy2, renamedelete2, dirmove2, movewithdir2) | ||||
| movewithdir1.update(movewithdir2) | |||||
| dirmove1.update(dirmove2) | |||||
| return branch_copies(copy1, renamedelete1, dirmove1, movewithdir1), diverge | return branch_copies1, branch_copies2, diverge | ||||
| def _dir_renames(repo, ctx, copy, fullcopy, addedfiles): | def _dir_renames(repo, ctx, copy, fullcopy, addedfiles): | ||||
| """Finds moved directories and files that should move with them. | """Finds moved directories and files that should move with them. | ||||
| ctx: the context for one of the sides | ctx: the context for one of the sides | ||||
| copy: files copied on the same side (as ctx) | copy: files copied on the same side (as ctx) | ||||
| fullcopy: files copied on the same side (as ctx), including those that | fullcopy: files copied on the same side (as ctx), including those that | ||||
| `experimental.copytrace.movecandidateslimit` which defaults to 100. | `experimental.copytrace.movecandidateslimit` which defaults to 100. | ||||
| """ | """ | ||||
| if c1.rev() is None: | if c1.rev() is None: | ||||
| c1 = c1.p1() | c1 = c1.p1() | ||||
| if c2.rev() is None: | if c2.rev() is None: | ||||
| c2 = c2.p1() | c2 = c2.p1() | ||||
| copies = {} | |||||
| changedfiles = set() | changedfiles = set() | ||||
| m1 = c1.manifest() | m1 = c1.manifest() | ||||
| if not repo.revs(b'%d::%d', base.rev(), c2.rev()): | if not repo.revs(b'%d::%d', base.rev(), c2.rev()): | ||||
| # If base is not in c2 branch, we switch to fullcopytracing | # If base is not in c2 branch, we switch to fullcopytracing | ||||
| repo.ui.debug( | repo.ui.debug( | ||||
| b"switching to full copytracing as base is not " | b"switching to full copytracing as base is not " | ||||
| b"an ancestor of c2\n" | b"an ancestor of c2\n" | ||||
| ) | ) | ||||
| return _fullcopytracing(repo, c1, c2, base) | return _fullcopytracing(repo, c1, c2, base) | ||||
| ctx = c2 | ctx = c2 | ||||
| while ctx != base: | while ctx != base: | ||||
| if len(ctx.parents()) == 2: | if len(ctx.parents()) == 2: | ||||
| # To keep things simple let's not handle merges | # To keep things simple let's not handle merges | ||||
| repo.ui.debug(b"switching to full copytracing because of merges\n") | repo.ui.debug(b"switching to full copytracing because of merges\n") | ||||
| return _fullcopytracing(repo, c1, c2, base) | return _fullcopytracing(repo, c1, c2, base) | ||||
| changedfiles.update(ctx.files()) | changedfiles.update(ctx.files()) | ||||
| ctx = ctx.p1() | ctx = ctx.p1() | ||||
| copies2 = {} | |||||
| cp = _forwardcopies(base, c2) | cp = _forwardcopies(base, c2) | ||||
| for dst, src in pycompat.iteritems(cp): | for dst, src in pycompat.iteritems(cp): | ||||
| if src in m1: | if src in m1: | ||||
| copies[dst] = src | copies2[dst] = src | ||||
| # file is missing if it isn't present in the destination, but is present in | # file is missing if it isn't present in the destination, but is present in | ||||
| # the base and present in the source. | # the base and present in the source. | ||||
| # Presence in the base is important to exclude added files, presence in the | # Presence in the base is important to exclude added files, presence in the | ||||
| # source is important to exclude removed files. | # source is important to exclude removed files. | ||||
| filt = lambda f: f not in m1 and f in base and f in c2 | filt = lambda f: f not in m1 and f in base and f in c2 | ||||
| missingfiles = [f for f in changedfiles if filt(f)] | missingfiles = [f for f in changedfiles if filt(f)] | ||||
| copies1 = {} | |||||
| if missingfiles: | if missingfiles: | ||||
| basenametofilename = collections.defaultdict(list) | basenametofilename = collections.defaultdict(list) | ||||
| dirnametofilename = collections.defaultdict(list) | dirnametofilename = collections.defaultdict(list) | ||||
| for f in m1.filesnotin(base.manifest()): | for f in m1.filesnotin(base.manifest()): | ||||
| basename = os.path.basename(f) | basename = os.path.basename(f) | ||||
| dirname = os.path.dirname(f) | dirname = os.path.dirname(f) | ||||
| basenametofilename[basename].append(f) | basenametofilename[basename].append(f) | ||||
| continue | continue | ||||
| for candidate in movecandidates: | for candidate in movecandidates: | ||||
| f1 = c1.filectx(candidate) | f1 = c1.filectx(candidate) | ||||
| if _related(f1, f2): | if _related(f1, f2): | ||||
| # if there are a few related copies then we'll merge | # if there are a few related copies then we'll merge | ||||
| # changes into all of them. This matches the behaviour | # changes into all of them. This matches the behaviour | ||||
| # of upstream copytracing | # of upstream copytracing | ||||
| copies[candidate] = f | copies1[candidate] = f | ||||
| return branch_copies(copies), {} | return branch_copies(copies1), branch_copies(copies2), {} | ||||
| def _related(f1, f2): | def _related(f1, f2): | ||||
| """return True if f1 and f2 filectx have a common ancestor | """return True if f1 and f2 filectx have a common ancestor | ||||
| Walk back to common ancestor to see if the two files originate | Walk back to common ancestor to see if the two files originate | ||||
| from the same file. Since workingfilectx's rev() is None it messes | from the same file. Since workingfilectx's rev() is None it messes | ||||
| up the integer comparison logic, hence the pre-step check for | up the integer comparison logic, hence the pre-step check for | ||||
| matcher = None | matcher = None | ||||
| # manifests fetched in order are going to be faster, so prime the caches | # manifests fetched in order are going to be faster, so prime the caches | ||||
| [ | [ | ||||
| x.manifest() | x.manifest() | ||||
| for x in sorted(wctx.parents() + [p2, pa], key=scmutil.intrev) | for x in sorted(wctx.parents() + [p2, pa], key=scmutil.intrev) | ||||
| ] | ] | ||||
| copy, movewithdir, diverge, renamedelete, dirmove = {}, {}, {}, {}, {} | branch_copies1 = copies.branch_copies() | ||||
| branch_copies2 = copies.branch_copies() | |||||
| diverge = {} | |||||
| if followcopies: | if followcopies: | ||||
| branch_copies, diverge = copies.mergecopies(repo, wctx, p2, pa) | branch_copies1, branch_copies2, diverge = copies.mergecopies(repo, wctx, p2, pa) | ||||
| copy = branch_copies.copy | |||||
| renamedelete = branch_copies.renamedelete | |||||
| dirmove = branch_copies.dirmove | |||||
| movewithdir = branch_copies.movewithdir | |||||
| boolbm = pycompat.bytestr(bool(branchmerge)) | boolbm = pycompat.bytestr(bool(branchmerge)) | ||||
| boolf = pycompat.bytestr(bool(force)) | boolf = pycompat.bytestr(bool(force)) | ||||
| boolm = pycompat.bytestr(bool(matcher)) | boolm = pycompat.bytestr(bool(matcher)) | ||||
| repo.ui.note(_(b"resolving manifests\n")) | repo.ui.note(_(b"resolving manifests\n")) | ||||
| repo.ui.debug( | repo.ui.debug( | ||||
| b" branchmerge: %s, force: %s, partial: %s\n" % (boolbm, boolf, boolm) | b" branchmerge: %s, force: %s, partial: %s\n" % (boolbm, boolf, boolm) | ||||
| ) | ) | ||||
| repo.ui.debug(b" ancestor: %s, local: %s, remote: %s\n" % (pa, wctx, p2)) | repo.ui.debug(b" ancestor: %s, local: %s, remote: %s\n" % (pa, wctx, p2)) | ||||
| m1, m2, ma = wctx.manifest(), p2.manifest(), pa.manifest() | m1, m2, ma = wctx.manifest(), p2.manifest(), pa.manifest() | ||||
| copied = set(copy.values()) | copied1 = set(branch_copies1.copy.values()) | ||||
| copied.update(movewithdir.values()) | copied1.update(branch_copies1.movewithdir.values()) | ||||
| copied2 = set(branch_copies2.copy.values()) | |||||
| copied2.update(branch_copies2.movewithdir.values()) | |||||
| if b'.hgsubstate' in m1 and wctx.rev() is None: | if b'.hgsubstate' in m1 and wctx.rev() is None: | ||||
| # Check whether sub state is modified, and overwrite the manifest | # Check whether sub state is modified, and overwrite the manifest | ||||
| # to flag the change. If wctx is a committed revision, we shouldn't | # to flag the change. If wctx is a committed revision, we shouldn't | ||||
| # care for the dirty state of the working directory. | # care for the dirty state of the working directory. | ||||
| if any(wctx.sub(s).dirty() for s in wctx.substate): | if any(wctx.sub(s).dirty() for s in wctx.substate): | ||||
| m1[b'.hgsubstate'] = modifiednodeid | m1[b'.hgsubstate'] = modifiednodeid | ||||
| # Don't use m2-vs-ma optimization if: | # Don't use m2-vs-ma optimization if: | ||||
| # - ma is the same as m1 or m2, which we're just going to diff again later | # - ma is the same as m1 or m2, which we're just going to diff again later | ||||
| # - The caller specifically asks for a full diff, which is useful during bid | # - The caller specifically asks for a full diff, which is useful during bid | ||||
| # merge. | # merge. | ||||
| if pa not in ([wctx, p2] + wctx.parents()) and not forcefulldiff: | if pa not in ([wctx, p2] + wctx.parents()) and not forcefulldiff: | ||||
| # Identify which files are relevant to the merge, so we can limit the | # Identify which files are relevant to the merge, so we can limit the | ||||
| # total m1-vs-m2 diff to just those files. This has significant | # total m1-vs-m2 diff to just those files. This has significant | ||||
| # performance benefits in large repositories. | # performance benefits in large repositories. | ||||
| relevantfiles = set(ma.diff(m2).keys()) | relevantfiles = set(ma.diff(m2).keys()) | ||||
| # For copied and moved files, we need to add the source file too. | # For copied and moved files, we need to add the source file too. | ||||
| for copykey, copyvalue in pycompat.iteritems(copy): | for copykey, copyvalue in pycompat.iteritems(branch_copies1.copy): | ||||
| if copyvalue in relevantfiles: | if copyvalue in relevantfiles: | ||||
| relevantfiles.add(copykey) | relevantfiles.add(copykey) | ||||
| for movedirkey in movewithdir: | for movedirkey in branch_copies1.movewithdir: | ||||
| relevantfiles.add(movedirkey) | relevantfiles.add(movedirkey) | ||||
| filesmatcher = scmutil.matchfiles(repo, relevantfiles) | filesmatcher = scmutil.matchfiles(repo, relevantfiles) | ||||
| matcher = matchmod.intersectmatchers(matcher, filesmatcher) | matcher = matchmod.intersectmatchers(matcher, filesmatcher) | ||||
| diff = m1.diff(m2, match=matcher) | diff = m1.diff(m2, match=matcher) | ||||
| actions = {} | actions = {} | ||||
| for f, ((n1, fl1), (n2, fl2)) in pycompat.iteritems(diff): | for f, ((n1, fl1), (n2, fl2)) in pycompat.iteritems(diff): | ||||
| if n1 and n2: # file exists on both local and remote side | if n1 and n2: # file exists on both local and remote side | ||||
| if f not in ma: | if f not in ma: | ||||
| fa = copy.get(f, None) | # TODO: what if they're renamed from different sources? | ||||
| fa = (branch_copies1.copy.get(f, None) or | |||||
| branch_copies2.copy.get(f, None)) | |||||
| if fa is not None: | if fa is not None: | ||||
| actions[f] = ( | actions[f] = ( | ||||
| ACTION_MERGE, | ACTION_MERGE, | ||||
| (f, f, fa, False, pa.node()), | (f, f, fa, False, pa.node()), | ||||
| b'both renamed from %s' % fa, | b'both renamed from %s' % fa, | ||||
| ) | ) | ||||
| else: | else: | ||||
| actions[f] = ( | actions[f] = ( | ||||
| actions[f] = (ACTION_GET, (fl1, False), b'remote is newer') | actions[f] = (ACTION_GET, (fl1, False), b'remote is newer') | ||||
| else: # both changed something | else: # both changed something | ||||
| actions[f] = ( | actions[f] = ( | ||||
| ACTION_MERGE, | ACTION_MERGE, | ||||
| (f, f, f, False, pa.node()), | (f, f, f, False, pa.node()), | ||||
| b'versions differ', | b'versions differ', | ||||
| ) | ) | ||||
| elif n1: # file exists only on local side | elif n1: # file exists only on local side | ||||
| if f in copied: | if f in copied2: | ||||
| pass # we'll deal with it on m2 side | pass # we'll deal with it on m2 side | ||||
| elif f in movewithdir: # directory rename, move local | elif f in branch_copies1.movewithdir: # directory rename, move local | ||||
| f2 = movewithdir[f] | f2 = branch_copies1.movewithdir[f] | ||||
| if f2 in m2: | if f2 in m2: | ||||
| actions[f2] = ( | actions[f2] = ( | ||||
| ACTION_MERGE, | ACTION_MERGE, | ||||
| (f, f2, None, True, pa.node()), | (f, f2, None, True, pa.node()), | ||||
| b'remote directory rename, both created', | b'remote directory rename, both created', | ||||
| ) | ) | ||||
| else: | else: | ||||
| actions[f2] = ( | actions[f2] = ( | ||||
| ACTION_DIR_RENAME_MOVE_LOCAL, | ACTION_DIR_RENAME_MOVE_LOCAL, | ||||
| (f, fl1), | (f, fl1), | ||||
| b'remote directory rename - move from %s' % f, | b'remote directory rename - move from %s' % f, | ||||
| ) | ) | ||||
| elif f in copy: | elif f in branch_copies1.copy: | ||||
| f2 = copy[f] | f2 = branch_copies1.copy[f] | ||||
| actions[f] = ( | actions[f] = ( | ||||
| ACTION_MERGE, | ACTION_MERGE, | ||||
| (f, f2, f2, False, pa.node()), | (f, f2, f2, False, pa.node()), | ||||
| b'local copied/moved from %s' % f2, | b'local copied/moved from %s' % f2, | ||||
| ) | ) | ||||
| elif f in ma: # clean, a different, no remote | elif f in ma: # clean, a different, no remote | ||||
| if n1 != ma[f]: | if n1 != ma[f]: | ||||
| if acceptremote: | if acceptremote: | ||||
| actions[f] = (ACTION_REMOVE, None, b'remote delete') | actions[f] = (ACTION_REMOVE, None, b'remote delete') | ||||
| else: | else: | ||||
| actions[f] = ( | actions[f] = ( | ||||
| ACTION_CHANGED_DELETED, | ACTION_CHANGED_DELETED, | ||||
| (f, None, f, False, pa.node()), | (f, None, f, False, pa.node()), | ||||
| b'prompt changed/deleted', | b'prompt changed/deleted', | ||||
| ) | ) | ||||
| elif n1 == addednodeid: | elif n1 == addednodeid: | ||||
| # This extra 'a' is added by working copy manifest to mark | # This extra 'a' is added by working copy manifest to mark | ||||
| # the file as locally added. We should forget it instead of | # the file as locally added. We should forget it instead of | ||||
| # deleting it. | # deleting it. | ||||
| actions[f] = (ACTION_FORGET, None, b'remote deleted') | actions[f] = (ACTION_FORGET, None, b'remote deleted') | ||||
| else: | else: | ||||
| actions[f] = (ACTION_REMOVE, None, b'other deleted') | actions[f] = (ACTION_REMOVE, None, b'other deleted') | ||||
| elif n2: # file exists only on remote side | elif n2: # file exists only on remote side | ||||
| if f in copied: | if f in copied1: | ||||
| pass # we'll deal with it on m1 side | pass # we'll deal with it on m1 side | ||||
| elif f in movewithdir: | elif f in branch_copies2.movewithdir: | ||||
| f2 = movewithdir[f] | f2 = branch_copies2.movewithdir[f] | ||||
| if f2 in m1: | if f2 in m1: | ||||
| actions[f2] = ( | actions[f2] = ( | ||||
| ACTION_MERGE, | ACTION_MERGE, | ||||
| (f2, f, None, False, pa.node()), | (f2, f, None, False, pa.node()), | ||||
| b'local directory rename, both created', | b'local directory rename, both created', | ||||
| ) | ) | ||||
| else: | else: | ||||
| actions[f2] = ( | actions[f2] = ( | ||||
| ACTION_LOCAL_DIR_RENAME_GET, | ACTION_LOCAL_DIR_RENAME_GET, | ||||
| (f, fl2), | (f, fl2), | ||||
| b'local directory rename - get from %s' % f, | b'local directory rename - get from %s' % f, | ||||
| ) | ) | ||||
| elif f in copy: | elif f in branch_copies2.copy: | ||||
| f2 = copy[f] | f2 = branch_copies2.copy[f] | ||||
| if f2 in m2: | if f2 in m2: | ||||
| actions[f] = ( | actions[f] = ( | ||||
| ACTION_MERGE, | ACTION_MERGE, | ||||
| (f2, f, f2, False, pa.node()), | (f2, f, f2, False, pa.node()), | ||||
| b'remote copied from %s' % f2, | b'remote copied from %s' % f2, | ||||
| ) | ) | ||||
| else: | else: | ||||
| actions[f] = ( | actions[f] = ( | ||||
| else: | else: | ||||
| actions[f] = ( | actions[f] = ( | ||||
| ACTION_CREATED_MERGE, | ACTION_CREATED_MERGE, | ||||
| (fl2, pa.node()), | (fl2, pa.node()), | ||||
| b'remote created, get or merge', | b'remote created, get or merge', | ||||
| ) | ) | ||||
| elif n2 != ma[f]: | elif n2 != ma[f]: | ||||
| df = None | df = None | ||||
| for d in dirmove: | for d in branch_copies1.dirmove: | ||||
| if f.startswith(d): | if f.startswith(d): | ||||
| # new file added in a directory that was moved | # new file added in a directory that was moved | ||||
| df = dirmove[d] + f[len(d) :] | df = branch_copies1.dirmove[d] + f[len(d):] | ||||
| break | break | ||||
| if df is not None and df in m1: | if df is not None and df in m1: | ||||
| actions[df] = ( | actions[df] = ( | ||||
| ACTION_MERGE, | ACTION_MERGE, | ||||
| (df, f, f, False, pa.node()), | (df, f, f, False, pa.node()), | ||||
| b'local directory rename - respect move ' | b'local directory rename - respect move ' | ||||
| b'from %s' % f, | b'from %s' % f, | ||||
| ) | ) | ||||
| # If we are merging, look for path conflicts. | # If we are merging, look for path conflicts. | ||||
| checkpathconflicts(repo, wctx, p2, actions) | checkpathconflicts(repo, wctx, p2, actions) | ||||
| narrowmatch = repo.narrowmatch() | narrowmatch = repo.narrowmatch() | ||||
| if not narrowmatch.always(): | if not narrowmatch.always(): | ||||
| # Updates "actions" in place | # Updates "actions" in place | ||||
| _filternarrowactions(narrowmatch, branchmerge, actions) | _filternarrowactions(narrowmatch, branchmerge, actions) | ||||
| renamedelete = branch_copies1.renamedelete | |||||
| renamedelete.update(branch_copies2.renamedelete) | |||||
| return actions, diverge, renamedelete | return actions, diverge, renamedelete | ||||
| def _resolvetrivial(repo, wctx, mctx, ancestor, actions): | def _resolvetrivial(repo, wctx, mctx, ancestor, actions): | ||||
| """Resolves false conflicts where the nodeid changed but the content | """Resolves false conflicts where the nodeid changed but the content | ||||
| remained the same.""" | remained the same.""" | ||||
| # We force a copy of actions.items() because we're going to mutate | # We force a copy of actions.items() because we're going to mutate | ||||
| # actions as we resolve trivial conflicts. | # actions as we resolve trivial conflicts. | ||||