Merge lp:~jelmer/brz/git-merge into lp:brz/3.1

[Jelmer Vernooij]

Some more improvements for merges in Git.

add test for git file merge.

[Jelmer Vernooij (jelmer)]

review: Approve

[The Breezy Bot (the-breezy-bot)]

Running landing tests failed
https://ci.breezy-vcs.org/job/brz-3.1/job/brz-3.1-land/303/

[The Breezy Bot (the-breezy-bot)]

Running landing tests failed
https://ci.breezy-vcs.org/job/brz-3.1/job/brz-3.1-land/304/

[The Breezy Bot (the-breezy-bot)]

Running landing tests failed
https://ci.breezy-vcs.org/job/brz-3.1/job/brz-3.1-land/305/

=== modified file 'breezy/bzr/tests/test_transform.py'
--- breezy/bzr/tests/test_transform.py	2020-07-03 00:43:31 +0000
+++ breezy/bzr/tests/test_transform.py	2020-09-02 17:42:36 +0000
@@ -14,6 +14,16 @@
 # along with this program; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
+import codecs
+import os
+import time
+
+from ...tests import features
+from ... import errors, filters, osutils, rules
+from ...controldir import ControlDir
+from ..conflicts import DuplicateEntry
+from ..transform import build_tree
+
 from . import TestCaseWithTransport
 
 
@@ -47,3 +57,410 @@
             tt.version_file(tt.root, file_id=tree.path2id(''))
             tt.trans_id_tree_path('foo')
             self.assertEqual([], tt._inventory_altered())
+
+
+class TestBuildTree(TestCaseWithTransport):
+
+    def test_build_tree_with_symlinks(self):
+        self.requireFeature(features.SymlinkFeature)
+        os.mkdir('a')
+        a = ControlDir.create_standalone_workingtree('a')
+        os.mkdir('a/foo')
+        with open('a/foo/bar', 'wb') as f:
+            f.write(b'contents')
+        os.symlink('a/foo/bar', 'a/foo/baz')
+        a.add(['foo', 'foo/bar', 'foo/baz'])
+        a.commit('initial commit')
+        b = ControlDir.create_standalone_workingtree('b')
+        basis = a.basis_tree()
+        basis.lock_read()
+        self.addCleanup(basis.unlock)
+        build_tree(basis, b)
+        self.assertIs(os.path.isdir('b/foo'), True)
+        with open('b/foo/bar', 'rb') as f:
+            self.assertEqual(f.read(), b"contents")
+        self.assertEqual(os.readlink('b/foo/baz'), 'a/foo/bar')
+
+    def test_build_with_references(self):
+        tree = self.make_branch_and_tree('source',
+                                         format='development-subtree')
+        subtree = self.make_branch_and_tree('source/subtree',
+                                            format='development-subtree')
+        tree.add_reference(subtree)
+        tree.commit('a revision')
+        tree.branch.create_checkout('target')
+        self.assertPathExists('target')
+        self.assertPathExists('target/subtree')
+
+    def test_file_conflict_handling(self):
+        """Ensure that when building trees, conflict handling is done"""
+        source = self.make_branch_and_tree('source')
+        target = self.make_branch_and_tree('target')
+        self.build_tree(['source/file', 'target/file'])
+        source.add('file', b'new-file')
+        source.commit('added file')
+        build_tree(source.basis_tree(), target)
+        self.assertEqual(
+            [DuplicateEntry('Moved existing file to', 'file.moved',
+                            'file', None, 'new-file')],
+            target.conflicts())
+        target2 = self.make_branch_and_tree('target2')
+        with open('target2/file', 'wb') as target_file, \
+                open('source/file', 'rb') as source_file:
+            target_file.write(source_file.read())
+        build_tree(source.basis_tree(), target2)
+        self.assertEqual([], target2.conflicts())
+
+    def test_symlink_conflict_handling(self):
+        """Ensure that when building trees, conflict handling is done"""
+        self.requireFeature(features.SymlinkFeature)
+        source = self.make_branch_and_tree('source')
+        os.symlink('foo', 'source/symlink')
+        source.add('symlink', b'new-symlink')
+        source.commit('added file')
+        target = self.make_branch_and_tree('target')
+        os.symlink('bar', 'target/symlink')
+        build_tree(source.basis_tree(), target)
+        self.assertEqual(
+            [DuplicateEntry('Moved existing file to', 'symlink.moved',
+                            'symlink', None, 'new-symlink')],
+            target.conflicts())
+        target = self.make_branch_and_tree('target2')
+        os.symlink('foo', 'target2/symlink')
+        build_tree(source.basis_tree(), target)
+        self.assertEqual([], target.conflicts())
+
+    def test_directory_conflict_handling(self):
+        """Ensure that when building trees, conflict handling is done"""
+        source = self.make_branch_and_tree('source')
+        target = self.make_branch_and_tree('target')
+        self.build_tree(['source/dir1/', 'source/dir1/file', 'target/dir1/'])
+        source.add(['dir1', 'dir1/file'], [b'new-dir1', b'new-file'])
+        source.commit('added file')
+        build_tree(source.basis_tree(), target)
+        self.assertEqual([], target.conflicts())
+        self.assertPathExists('target/dir1/file')
+
+        # Ensure contents are merged
+        target = self.make_branch_and_tree('target2')
+        self.build_tree(['target2/dir1/', 'target2/dir1/file2'])
+        build_tree(source.basis_tree(), target)
+        self.assertEqual([], target.conflicts())
+        self.assertPathExists('target2/dir1/file2')
+        self.assertPathExists('target2/dir1/file')
+
+        # Ensure new contents are suppressed for existing branches
+        target = self.make_branch_and_tree('target3')
+        self.make_branch('target3/dir1')
+        self.build_tree(['target3/dir1/file2'])
+        build_tree(source.basis_tree(), target)
+        self.assertPathDoesNotExist('target3/dir1/file')
+        self.assertPathExists('target3/dir1/file2')
+        self.assertPathExists('target3/dir1.diverted/file')
+        self.assertEqual(
+            [DuplicateEntry('Diverted to', 'dir1.diverted',
+                            'dir1', 'new-dir1', None)],
+            target.conflicts())
+
+        target = self.make_branch_and_tree('target4')
+        self.build_tree(['target4/dir1/'])
+        self.make_branch('target4/dir1/file')
+        build_tree(source.basis_tree(), target)
+        self.assertPathExists('target4/dir1/file')
+        self.assertEqual('directory', osutils.file_kind('target4/dir1/file'))
+        self.assertPathExists('target4/dir1/file.diverted')
+        self.assertEqual(
+            [DuplicateEntry('Diverted to', 'dir1/file.diverted',
+                            'dir1/file', 'new-file', None)],
+            target.conflicts())
+
+    def test_mixed_conflict_handling(self):
+        """Ensure that when building trees, conflict handling is done"""
+        source = self.make_branch_and_tree('source')
+        target = self.make_branch_and_tree('target')
+        self.build_tree(['source/name', 'target/name/'])
+        source.add('name', b'new-name')
+        source.commit('added file')
+        build_tree(source.basis_tree(), target)
+        self.assertEqual(
+            [DuplicateEntry('Moved existing file to',
+                            'name.moved', 'name', None, 'new-name')],
+            target.conflicts())
+
+    def test_raises_in_populated(self):
+        source = self.make_branch_and_tree('source')
+        self.build_tree(['source/name'])
+        source.add('name')
+        source.commit('added name')
+        target = self.make_branch_and_tree('target')
+        self.build_tree(['target/name'])
+        target.add('name')
+        self.assertRaises(errors.WorkingTreeAlreadyPopulated,
+                          build_tree, source.basis_tree(), target)
+
+    def test_build_tree_rename_count(self):
+        source = self.make_branch_and_tree('source')
+        self.build_tree(['source/file1', 'source/dir1/'])
+        source.add(['file1', 'dir1'])
+        source.commit('add1')
+        target1 = self.make_branch_and_tree('target1')
+        transform_result = build_tree(source.basis_tree(), target1)
+        self.assertEqual(2, transform_result.rename_count)
+
+        self.build_tree(['source/dir1/file2'])
+        source.add(['dir1/file2'])
+        source.commit('add3')
+        target2 = self.make_branch_and_tree('target2')
+        transform_result = build_tree(source.basis_tree(), target2)
+        # children of non-root directories should not be renamed
+        self.assertEqual(2, transform_result.rename_count)
+
+    def create_ab_tree(self):
+        """Create a committed test tree with two files"""
+        source = self.make_branch_and_tree('source')
+        self.build_tree_contents([('source/file1', b'A')])
+        self.build_tree_contents([('source/file2', b'B')])
+        source.add(['file1', 'file2'], [b'file1-id', b'file2-id'])
+        source.commit('commit files')
+        source.lock_write()
+        self.addCleanup(source.unlock)
+        return source
+
+    def test_build_tree_accelerator_tree(self):
+        source = self.create_ab_tree()
+        self.build_tree_contents([('source/file2', b'C')])
+        calls = []
+        real_source_get_file = source.get_file
+
+        def get_file(path):
+            calls.append(path)
+            return real_source_get_file(path)
+        source.get_file = get_file
+        target = self.make_branch_and_tree('target')
+        revision_tree = source.basis_tree()
+        revision_tree.lock_read()
+        self.addCleanup(revision_tree.unlock)
+        build_tree(revision_tree, target, source)
+        self.assertEqual(['file1'], calls)
+        target.lock_read()
+        self.addCleanup(target.unlock)
+        self.assertEqual([], list(target.iter_changes(revision_tree)))
+
+    def test_build_tree_accelerator_tree_observes_sha1(self):
+        source = self.create_ab_tree()
+        sha1 = osutils.sha_string(b'A')
+        target = self.make_branch_and_tree('target')
+        target.lock_write()
+        self.addCleanup(target.unlock)
+        state = target.current_dirstate()
+        state._cutoff_time = time.time() + 60
+        build_tree(source.basis_tree(), target, source)
+        entry = state._get_entry(0, path_utf8=b'file1')
+        self.assertEqual(sha1, entry[1][0][1])
+
+    def test_build_tree_accelerator_tree_missing_file(self):
+        source = self.create_ab_tree()
+        os.unlink('source/file1')
+        source.remove(['file2'])
+        target = self.make_branch_and_tree('target')
+        revision_tree = source.basis_tree()
+        revision_tree.lock_read()
+        self.addCleanup(revision_tree.unlock)
+        build_tree(revision_tree, target, source)
+        target.lock_read()
+        self.addCleanup(target.unlock)
+        self.assertEqual([], list(target.iter_changes(revision_tree)))
+
+    def test_build_tree_accelerator_wrong_kind(self):
+        self.requireFeature(features.SymlinkFeature)
+        source = self.make_branch_and_tree('source')
+        self.build_tree_contents([('source/file1', b'')])
+        self.build_tree_contents([('source/file2', b'')])
+        source.add(['file1', 'file2'], [b'file1-id', b'file2-id'])
+        source.commit('commit files')
+        os.unlink('source/file2')
+        self.build_tree_contents([('source/file2/', b'C')])
+        os.unlink('source/file1')
+        os.symlink('file2', 'source/file1')
+        calls = []
+        real_source_get_file = source.get_file
+
+        def get_file(path):
+            calls.append(path)
+            return real_source_get_file(path)
+        source.get_file = get_file
+        target = self.make_branch_and_tree('target')
+        revision_tree = source.basis_tree()
+        revision_tree.lock_read()
+        self.addCleanup(revision_tree.unlock)
+        build_tree(revision_tree, target, source)
+        self.assertEqual([], calls)
+        target.lock_read()
+        self.addCleanup(target.unlock)
+        self.assertEqual([], list(target.iter_changes(revision_tree)))
+
+    def test_build_tree_hardlink(self):
+        self.requireFeature(features.HardlinkFeature)
+        source = self.create_ab_tree()
+        target = self.make_branch_and_tree('target')
+        revision_tree = source.basis_tree()
+        revision_tree.lock_read()
+        self.addCleanup(revision_tree.unlock)
+        build_tree(revision_tree, target, source, hardlink=True)
+        target.lock_read()
+        self.addCleanup(target.unlock)
+        self.assertEqual([], list(target.iter_changes(revision_tree)))
+        source_stat = os.stat('source/file1')
+        target_stat = os.stat('target/file1')
+        self.assertEqual(source_stat, target_stat)
+
+        # Explicitly disallowing hardlinks should prevent them.
+        target2 = self.make_branch_and_tree('target2')
+        build_tree(revision_tree, target2, source, hardlink=False)
+        target2.lock_read()
+        self.addCleanup(target2.unlock)
+        self.assertEqual([], list(target2.iter_changes(revision_tree)))
+        source_stat = os.stat('source/file1')
+        target2_stat = os.stat('target2/file1')
+        self.assertNotEqual(source_stat, target2_stat)
+
+    def test_build_tree_accelerator_tree_moved(self):
+        source = self.make_branch_and_tree('source')
+        self.build_tree_contents([('source/file1', b'A')])
+        source.add(['file1'], [b'file1-id'])
+        source.commit('commit files')
+        source.rename_one('file1', 'file2')
+        source.lock_read()
+        self.addCleanup(source.unlock)
+        target = self.make_branch_and_tree('target')
+        revision_tree = source.basis_tree()
+        revision_tree.lock_read()
+        self.addCleanup(revision_tree.unlock)
+        build_tree(revision_tree, target, source)
+        target.lock_read()
+        self.addCleanup(target.unlock)
+        self.assertEqual([], list(target.iter_changes(revision_tree)))
+
+    def test_build_tree_hardlinks_preserve_execute(self):
+        self.requireFeature(features.HardlinkFeature)
+        source = self.create_ab_tree()
+        tt = source.transform()
+        trans_id = tt.trans_id_tree_path('file1')
+        tt.set_executability(True, trans_id)
+        tt.apply()
+        self.assertTrue(source.is_executable('file1'))
+        target = self.make_branch_and_tree('target')
+        revision_tree = source.basis_tree()
+        revision_tree.lock_read()
+        self.addCleanup(revision_tree.unlock)
+        build_tree(revision_tree, target, source, hardlink=True)
+        target.lock_read()
+        self.addCleanup(target.unlock)
+        self.assertEqual([], list(target.iter_changes(revision_tree)))
+        self.assertTrue(source.is_executable('file1'))
+
+    def install_rot13_content_filter(self, pattern):
+        # We could use
+        # self.addCleanup(filters._reset_registry, filters._reset_registry())
+        # below, but that looks a bit... hard to read even if it's exactly
+        # the same thing.
+        original_registry = filters._reset_registry()
+
+        def restore_registry():
+            filters._reset_registry(original_registry)
+        self.addCleanup(restore_registry)
+
+        def rot13(chunks, context=None):
+            return [
+                codecs.encode(chunk.decode('ascii'), 'rot13').encode('ascii')
+                for chunk in chunks]
+        rot13filter = filters.ContentFilter(rot13, rot13)
+        filters.filter_stacks_registry.register(
+            'rot13', {'yes': [rot13filter]}.get)
+        os.mkdir(self.test_home_dir + '/.bazaar')
+        rules_filename = self.test_home_dir + '/.bazaar/rules'
+        with open(rules_filename, 'wb') as f:
+            f.write(b'[name %s]\nrot13=yes\n' % (pattern,))
+
+        def uninstall_rules():
+            os.remove(rules_filename)
+            rules.reset_rules()
+        self.addCleanup(uninstall_rules)
+        rules.reset_rules()
+
+    def test_build_tree_content_filtered_files_are_not_hardlinked(self):
+        """build_tree will not hardlink files that have content filtering rules
+        applied to them (but will still hardlink other files from the same tree
+        if it can).
+        """
+        self.requireFeature(features.HardlinkFeature)
+        self.install_rot13_content_filter(b'file1')
+        source = self.create_ab_tree()
+        target = self.make_branch_and_tree('target')
+        revision_tree = source.basis_tree()
+        revision_tree.lock_read()
+        self.addCleanup(revision_tree.unlock)
+        build_tree(revision_tree, target, source, hardlink=True)
+        target.lock_read()
+        self.addCleanup(target.unlock)
+        self.assertEqual([], list(target.iter_changes(revision_tree)))
+        source_stat = os.stat('source/file1')
+        target_stat = os.stat('target/file1')
+        self.assertNotEqual(source_stat, target_stat)
+        source_stat = os.stat('source/file2')
+        target_stat = os.stat('target/file2')
+        self.assertEqualStat(source_stat, target_stat)
+
+    def test_case_insensitive_build_tree_inventory(self):
+        if (features.CaseInsensitiveFilesystemFeature.available()
+                or features.CaseInsCasePresFilenameFeature.available()):
+            raise tests.UnavailableFeature('Fully case sensitive filesystem')
+        source = self.make_branch_and_tree('source')
+        self.build_tree(['source/file', 'source/FILE'])
+        source.add(['file', 'FILE'], [b'lower-id', b'upper-id'])
+        source.commit('added files')
+        # Don't try this at home, kids!
+        # Force the tree to report that it is case insensitive
+        target = self.make_branch_and_tree('target')
+        target.case_sensitive = False
+        build_tree(source.basis_tree(), target, source, delta_from_tree=True)
+        self.assertEqual('file.moved', target.id2path(b'lower-id'))
+        self.assertEqual('FILE', target.id2path(b'upper-id'))
+
+    def test_build_tree_observes_sha(self):
+        source = self.make_branch_and_tree('source')
+        self.build_tree(['source/file1', 'source/dir/', 'source/dir/file2'])
+        source.add(['file1', 'dir', 'dir/file2'],
+                   [b'file1-id', b'dir-id', b'file2-id'])
+        source.commit('new files')
+        target = self.make_branch_and_tree('target')
+        target.lock_write()
+        self.addCleanup(target.unlock)
+        # We make use of the fact that DirState caches its cutoff time. So we
+        # set the 'safe' time to one minute in the future.
+        state = target.current_dirstate()
+        state._cutoff_time = time.time() + 60
+        build_tree(source.basis_tree(), target)
+        entry1_sha = osutils.sha_file_by_name('source/file1')
+        entry2_sha = osutils.sha_file_by_name('source/dir/file2')
+        # entry[1] is the state information, entry[1][0] is the state of the
+        # working tree, entry[1][0][1] is the sha value for the current working
+        # tree
+        entry1 = state._get_entry(0, path_utf8=b'file1')
+        self.assertEqual(entry1_sha, entry1[1][0][1])
+        # The 'size' field must also be set.
+        self.assertEqual(25, entry1[1][0][2])
+        entry1_state = entry1[1][0]
+        entry2 = state._get_entry(0, path_utf8=b'dir/file2')
+        self.assertEqual(entry2_sha, entry2[1][0][1])
+        self.assertEqual(29, entry2[1][0][2])
+        entry2_state = entry2[1][0]
+        # Now, make sure that we don't have to re-read the content. The
+        # packed_stat should match exactly.
+        self.assertEqual(entry1_sha, target.get_file_sha1('file1'))
+        self.assertEqual(entry2_sha, target.get_file_sha1('dir/file2'))
+        self.assertEqual(entry1_state, entry1[1][0])
+        self.assertEqual(entry2_state, entry2[1][0])
+
+
+

=== modified file 'breezy/bzr/transform.py'
--- breezy/bzr/transform.py	2020-08-15 15:06:56 +0000
+++ breezy/bzr/transform.py	2020-09-02 17:42:36 +0000
@@ -24,7 +24,9 @@
 
 from .. import (
     annotate,
+    cleanup,
     conflicts,
+    controldir,
     errors,
     lock,
     multiparent,
@@ -36,8 +38,10 @@
     urlutils,
     )
 
+from ..filters import filtered_output_bytes, ContentFilterContext
 from ..i18n import gettext
 from ..mutabletree import MutableTree
+from ..progress import ProgressPhase
 from ..sixish import text_type, viewvalues, viewitems
 from ..transform import (
     ROOT_PARENT,
@@ -53,7 +57,11 @@
     ReusingTransform,
     MalformedTransform,
     PreviewTree,
+    new_by_entry,
+    _reparent_children,
+    resolve_conflicts,
     )
+from ..tree import find_previous_path
 from .conflicts import Conflict
 
 from . import (
@@ -62,6 +70,22 @@
     )
 
 
+def _content_match(tree, entry, tree_path, kind, target_path):
+    if entry.kind != kind:
+        return False
+    if entry.kind == "directory":
+        return True
+    if entry.kind == "file":
+        with open(target_path, 'rb') as f1, \
+                tree.get_file(tree_path) as f2:
+            if osutils.compare_files(f1, f2):
+                return True
+    elif entry.kind == "symlink":
+        if tree.get_symlink_target(tree_path) == os.readlink(target_path):
+            return True
+    return False
+
+
 class TreeTransformBase(TreeTransform):
     """The base class for TreeTransform and its kin."""
 
@@ -388,7 +412,6 @@
 
     def _parent_loops(self):
         """No entry should be its own ancestor"""
-        conflicts = []
         for trans_id in self._new_parent:
             seen = set()
             parent_id = trans_id
@@ -399,14 +422,12 @@
                 except KeyError:
                     break
                 if parent_id == trans_id:
-                    conflicts.append(('parent loop', trans_id))
+                    yield ('parent loop', trans_id)
                 if parent_id in seen:
                     break
-        return conflicts
 
     def _unversioned_parents(self, by_parent):
         """If parent directories are versioned, children must be versioned."""
-        conflicts = []
         for parent_id, children in viewitems(by_parent):
             if parent_id == ROOT_PARENT:
                 continue
@@ -414,27 +435,24 @@
                 continue
             for child_id in children:
                 if self.final_is_versioned(child_id):
-                    conflicts.append(('unversioned parent', parent_id))
+                    yield ('unversioned parent', parent_id)
                     break
-        return conflicts
 
     def _improper_versioning(self):
         """Cannot version a file with no contents, or a bad type.
 
         However, existing entries with no contents are okay.
         """
-        conflicts = []
         for trans_id in self._new_id:
             kind = self.final_kind(trans_id)
             if kind == 'symlink' and not self._tree.supports_symlinks():
                 # Ignore symlinks as they are not supported on this platform
                 continue
             if kind is None:
-                conflicts.append(('versioning no contents', trans_id))
+                yield ('versioning no contents', trans_id)
                 continue
             if not self._tree.versionable_kind(kind):
-                conflicts.append(('versioning bad kind', trans_id, kind))
-        return conflicts
+                yield ('versioning bad kind', trans_id, kind)
 
     def _executability_conflicts(self):
         """Check for bad executability changes.
@@ -444,31 +462,25 @@
         2. only files can be executable.  (The execute bit on a directory
            does not indicate searchability)
         """
-        conflicts = []
         for trans_id in self._new_executability:
             if not self.final_is_versioned(trans_id):
-                conflicts.append(('unversioned executability', trans_id))
+                yield ('unversioned executability', trans_id)
             else:
                 if self.final_kind(trans_id) != "file":
-                    conflicts.append(('non-file executability', trans_id))
-        return conflicts
+                    yield ('non-file executability', trans_id)
 
     def _overwrite_conflicts(self):
         """Check for overwrites (not permitted on Win32)"""
-        conflicts = []
         for trans_id in self._new_contents:
             if self.tree_kind(trans_id) is None:
                 continue
             if trans_id not in self._removed_contents:
-                conflicts.append(('overwrite', trans_id,
-                                  self.final_name(trans_id)))
-        return conflicts
+                yield ('overwrite', trans_id, self.final_name(trans_id))
 
     def _duplicate_entries(self, by_parent):
         """No directory may have two entries with the same name."""
-        conflicts = []
         if (self._new_name, self._new_parent) == ({}, {}):
-            return conflicts
+            return
         for children in viewvalues(by_parent):
             name_ids = []
             for child_tid in children:
@@ -486,15 +498,12 @@
                 if kind is None and not self.final_is_versioned(trans_id):
                     continue
                 if name == last_name:
-                    conflicts.append(('duplicate', last_trans_id, trans_id,
-                                      name))
+                    yield ('duplicate', last_trans_id, trans_id, name)
                 last_name = name
                 last_trans_id = trans_id
-        return conflicts
 
     def _parent_type_conflicts(self, by_parent):
         """Children must have a directory parent"""
-        conflicts = []
         for parent_id, children in viewitems(by_parent):
             if parent_id == ROOT_PARENT:
                 continue
@@ -510,11 +519,10 @@
             kind = self.final_kind(parent_id)
             if kind is None:
                 # The directory will be deleted
-                conflicts.append(('missing parent', parent_id))
+                yield ('missing parent', parent_id)
             elif kind != "directory":
                 # Meh, we need a *directory* to put something in it
-                conflicts.append(('non-directory parent', parent_id))
-        return conflicts
+                yield ('non-directory parent', parent_id)
 
     def _set_executability(self, path, trans_id):
         """Set the executability of versioned files """
@@ -2253,3 +2261,230 @@
         trans_id = self._path2trans_id(path)
         name = self._transform._limbo_name(trans_id)
         return open(name, 'rb')
+
+
+def build_tree(tree, wt, accelerator_tree=None, hardlink=False,
+               delta_from_tree=False):
+    """Create working tree for a branch, using a TreeTransform.
+
+    This function should be used on empty trees, having a tree root at most.
+    (see merge and revert functionality for working with existing trees)
+
+    Existing files are handled like so:
+
+    - Existing bzrdirs take precedence over creating new items.  They are
+      created as '%s.diverted' % name.
+    - Otherwise, if the content on disk matches the content we are building,
+      it is silently replaced.
+    - Otherwise, conflict resolution will move the old file to 'oldname.moved'.
+
+    :param tree: The tree to convert wt into a copy of
+    :param wt: The working tree that files will be placed into
+    :param accelerator_tree: A tree which can be used for retrieving file
+        contents more quickly than tree itself, i.e. a workingtree.  tree
+        will be used for cases where accelerator_tree's content is different.
+    :param hardlink: If true, hard-link files to accelerator_tree, where
+        possible.  accelerator_tree must implement abspath, i.e. be a
+        working tree.
+    :param delta_from_tree: If true, build_tree may use the input Tree to
+        generate the inventory delta.
+    """
+    with cleanup.ExitStack() as exit_stack:
+        exit_stack.enter_context(wt.lock_tree_write())
+        exit_stack.enter_context(tree.lock_read())
+        if accelerator_tree is not None:
+            exit_stack.enter_context(accelerator_tree.lock_read())
+        return _build_tree(tree, wt, accelerator_tree, hardlink,
+                           delta_from_tree)
+
+
+def resolve_checkout(tt, conflicts, divert):
+    new_conflicts = set()
+    for c_type, conflict in ((c[0], c) for c in conflicts):
+        # Anything but a 'duplicate' would indicate programmer error
+        if c_type != 'duplicate':
+            raise AssertionError(c_type)
+        # Now figure out which is new and which is old
+        if tt.new_contents(conflict[1]):
+            new_file = conflict[1]
+            old_file = conflict[2]
+        else:
+            new_file = conflict[2]
+            old_file = conflict[1]
+
+        # We should only get here if the conflict wasn't completely
+        # resolved
+        final_parent = tt.final_parent(old_file)
+        if new_file in divert:
+            new_name = tt.final_name(old_file) + '.diverted'
+            tt.adjust_path(new_name, final_parent, new_file)
+            new_conflicts.add((c_type, 'Diverted to',
+                               new_file, old_file))
+        else:
+            new_name = tt.final_name(old_file) + '.moved'
+            tt.adjust_path(new_name, final_parent, old_file)
+            new_conflicts.add((c_type, 'Moved existing file to',
+                               old_file, new_file))
+    return new_conflicts
+
+
+def _build_tree(tree, wt, accelerator_tree, hardlink, delta_from_tree):
+    """See build_tree."""
+    for num, _unused in enumerate(wt.all_versioned_paths()):
+        if num > 0:  # more than just a root
+            raise errors.WorkingTreeAlreadyPopulated(base=wt.basedir)
+    file_trans_id = {}
+    top_pb = ui.ui_factory.nested_progress_bar()
+    pp = ProgressPhase("Build phase", 2, top_pb)
+    if tree.path2id('') is not None:
+        # This is kind of a hack: we should be altering the root
+        # as part of the regular tree shape diff logic.
+        # The conditional test here is to avoid doing an
+        # expensive operation (flush) every time the root id
+        # is set within the tree, nor setting the root and thus
+        # marking the tree as dirty, because we use two different
+        # idioms here: tree interfaces and inventory interfaces.
+        if wt.path2id('') != tree.path2id(''):
+            wt.set_root_id(tree.path2id(''))
+            wt.flush()
+    tt = wt.transform()
+    divert = set()
+    try:
+        pp.next_phase()
+        file_trans_id[find_previous_path(wt, tree, '')] = tt.trans_id_tree_path('')
+        with ui.ui_factory.nested_progress_bar() as pb:
+            deferred_contents = []
+            num = 0
+            total = len(tree.all_versioned_paths())
+            if delta_from_tree:
+                precomputed_delta = []
+            else:
+                precomputed_delta = None
+            # Check if tree inventory has content. If so, we populate
+            # existing_files with the directory content. If there are no
+            # entries we skip populating existing_files as its not used.
+            # This improves performance and unncessary work on large
+            # directory trees. (#501307)
+            if total > 0:
+                existing_files = set()
+                for dir, files in wt.walkdirs():
+                    existing_files.update(f[0] for f in files)
+            for num, (tree_path, entry) in \
+                    enumerate(tree.iter_entries_by_dir()):
+                pb.update(gettext("Building tree"), num
+                          - len(deferred_contents), total)
+                if entry.parent_id is None:
+                    continue
+                reparent = False
+                file_id = entry.file_id
+                if delta_from_tree:
+                    precomputed_delta.append((None, tree_path, file_id, entry))
+                if tree_path in existing_files:
+                    target_path = wt.abspath(tree_path)
+                    kind = osutils.file_kind(target_path)
+                    if kind == "directory":
+                        try:
+                            controldir.ControlDir.open(target_path)
+                        except errors.NotBranchError:
+                            pass
+                        else:
+                            divert.add(tree_path)
+                    if (tree_path not in divert
+                        and _content_match(
+                            tree, entry, tree_path, kind, target_path)):
+                        tt.delete_contents(tt.trans_id_tree_path(tree_path))
+                        if kind == 'directory':
+                            reparent = True
+                parent_id = file_trans_id[osutils.dirname(tree_path)]
+                if entry.kind == 'file':
+                    # We *almost* replicate new_by_entry, so that we can defer
+                    # getting the file text, and get them all at once.
+                    trans_id = tt.create_path(entry.name, parent_id)
+                    file_trans_id[tree_path] = trans_id
+                    tt.version_file(trans_id, file_id=file_id)
+                    executable = tree.is_executable(tree_path)
+                    if executable:
+                        tt.set_executability(executable, trans_id)
+                    trans_data = (trans_id, tree_path, entry.text_sha1)
+                    deferred_contents.append((tree_path, trans_data))
+                else:
+                    file_trans_id[tree_path] = new_by_entry(
+                        tree_path, tt, entry, parent_id, tree)
+                if reparent:
+                    new_trans_id = file_trans_id[tree_path]
+                    old_parent = tt.trans_id_tree_path(tree_path)
+                    _reparent_children(tt, old_parent, new_trans_id)
+            offset = num + 1 - len(deferred_contents)
+            _create_files(tt, tree, deferred_contents, pb, offset,
+                          accelerator_tree, hardlink)
+        pp.next_phase()
+        divert_trans = set(file_trans_id[f] for f in divert)
+
+        def resolver(t, c):
+            return resolve_checkout(t, c, divert_trans)
+        raw_conflicts = resolve_conflicts(tt, pass_func=resolver)
+        if len(raw_conflicts) > 0:
+            precomputed_delta = None
+        conflicts = tt.cook_conflicts(raw_conflicts)
+        for conflict in conflicts:
+            trace.warning(text_type(conflict))
+        try:
+            wt.add_conflicts(conflicts)
+        except errors.UnsupportedOperation:
+            pass
+        result = tt.apply(no_conflicts=True,
+                          precomputed_delta=precomputed_delta)
+    finally:
+        tt.finalize()
+        top_pb.finished()
+    return result
+
+
+def _create_files(tt, tree, desired_files, pb, offset, accelerator_tree,
+                  hardlink):
+    total = len(desired_files) + offset
+    wt = tt._tree
+    if accelerator_tree is None:
+        new_desired_files = desired_files
+    else:
+        iter = accelerator_tree.iter_changes(tree, include_unchanged=True)
+        unchanged = [
+            change.path for change in iter
+            if not (change.changed_content or change.executable[0] != change.executable[1])]
+        if accelerator_tree.supports_content_filtering():
+            unchanged = [(tp, ap) for (tp, ap) in unchanged
+                         if not next(accelerator_tree.iter_search_rules([ap]))]
+        unchanged = dict(unchanged)
+        new_desired_files = []
+        count = 0
+        for unused_tree_path, (trans_id, tree_path, text_sha1) in desired_files:
+            accelerator_path = unchanged.get(tree_path)
+            if accelerator_path is None:
+                new_desired_files.append((tree_path,
+                                          (trans_id, tree_path, text_sha1)))
+                continue
+            pb.update(gettext('Adding file contents'), count + offset, total)
+            if hardlink:
+                tt.create_hardlink(accelerator_tree.abspath(accelerator_path),
+                                   trans_id)
+            else:
+                with accelerator_tree.get_file(accelerator_path) as f:
+                    chunks = osutils.file_iterator(f)
+                    if wt.supports_content_filtering():
+                        filters = wt._content_filter_stack(tree_path)
+                        chunks = filtered_output_bytes(chunks, filters,
+                                                       ContentFilterContext(tree_path, tree))
+                    tt.create_file(chunks, trans_id, sha1=text_sha1)
+            count += 1
+        offset += count
+    for count, ((trans_id, tree_path, text_sha1), contents) in enumerate(
+            tree.iter_files_bytes(new_desired_files)):
+        if wt.supports_content_filtering():
+            filters = wt._content_filter_stack(tree_path)
+            contents = filtered_output_bytes(contents, filters,
+                                             ContentFilterContext(tree_path, tree))
+        tt.create_file(contents, trans_id, sha1=text_sha1)
+        pb.update(gettext('Adding file contents'), count + offset, total)
+
+
+

=== modified file 'breezy/bzr/workingtree.py'
--- breezy/bzr/workingtree.py	2020-08-09 19:38:19 +0000
+++ breezy/bzr/workingtree.py	2020-09-02 17:42:36 +0000
@@ -57,6 +57,7 @@
     conflicts as _mod_conflicts,
     globbing,
     ignores,
+    merge,
     revision as _mod_revision,
     rio as _mod_rio,
     )
@@ -1867,6 +1868,139 @@
                     return False
                 return True
 
+    _marker = object()
+
+    def update(self, change_reporter=None, possible_transports=None,
+               revision=None, old_tip=_marker, show_base=False):
+        """Update a working tree along its branch.
+
+        This will update the branch if its bound too, which means we have
+        multiple trees involved:
+
+        - The new basis tree of the master.
+        - The old basis tree of the branch.
+        - The old basis tree of the working tree.
+        - The current working tree state.
+
+        Pathologically, all three may be different, and non-ancestors of each
+        other.  Conceptually we want to:
+
+        - Preserve the wt.basis->wt.state changes
+        - Transform the wt.basis to the new master basis.
+        - Apply a merge of the old branch basis to get any 'local' changes from
+          it into the tree.
+        - Restore the wt.basis->wt.state changes.
+
+        There isn't a single operation at the moment to do that, so we:
+
+        - Merge current state -> basis tree of the master w.r.t. the old tree
+          basis.
+        - Do a 'normal' merge of the old branch basis if it is relevant.
+
+        :param revision: The target revision to update to. Must be in the
+            revision history.
+        :param old_tip: If branch.update() has already been run, the value it
+            returned (old tip of the branch or None). _marker is used
+            otherwise.
+        """
+        if self.branch.get_bound_location() is not None:
+            self.lock_write()
+            update_branch = (old_tip is self._marker)
+        else:
+            self.lock_tree_write()
+            update_branch = False
+        try:
+            if update_branch:
+                old_tip = self.branch.update(possible_transports)
+            else:
+                if old_tip is self._marker:
+                    old_tip = None
+            return self._update_tree(old_tip, change_reporter, revision, show_base)
+        finally:
+            self.unlock()
+
+    def _update_tree(self, old_tip=None, change_reporter=None, revision=None,
+                     show_base=False):
+        """Update a tree to the master branch.
+
+        :param old_tip: if supplied, the previous tip revision the branch,
+            before it was changed to the master branch's tip.
+        """
+        # here if old_tip is not None, it is the old tip of the branch before
+        # it was updated from the master branch. This should become a pending
+        # merge in the working tree to preserve the user existing work.  we
+        # cant set that until we update the working trees last revision to be
+        # one from the new branch, because it will just get absorbed by the
+        # parent de-duplication logic.
+        #
+        # We MUST save it even if an error occurs, because otherwise the users
+        # local work is unreferenced and will appear to have been lost.
+        #
+        with self.lock_tree_write():
+            nb_conflicts = 0
+            try:
+                last_rev = self.get_parent_ids()[0]
+            except IndexError:
+                last_rev = _mod_revision.NULL_REVISION
+            if revision is None:
+                revision = self.branch.last_revision()
+
+            old_tip = old_tip or _mod_revision.NULL_REVISION
+
+            if not _mod_revision.is_null(old_tip) and old_tip != last_rev:
+                # the branch we are bound to was updated
+                # merge those changes in first
+                base_tree = self.basis_tree()
+                other_tree = self.branch.repository.revision_tree(old_tip)
+                nb_conflicts = merge.merge_inner(self.branch, other_tree,
+                                                 base_tree, this_tree=self,
+                                                 change_reporter=change_reporter,
+                                                 show_base=show_base)
+                if nb_conflicts:
+                    self.add_parent_tree((old_tip, other_tree))
+                    return nb_conflicts
+
+            if last_rev != _mod_revision.ensure_null(revision):
+                # the working tree is up to date with the branch
+                # we can merge the specified revision from master
+                to_tree = self.branch.repository.revision_tree(revision)
+                to_root_id = to_tree.path2id('')
+
+                basis = self.basis_tree()
+                with basis.lock_read():
+                    if (basis.path2id('') is None or basis.path2id('') != to_root_id):
+                        self.set_root_id(to_root_id)
+                        self.flush()
+
+                # determine the branch point
+                graph = self.branch.repository.get_graph()
+                base_rev_id = graph.find_unique_lca(self.branch.last_revision(),
+                                                    last_rev)
+                base_tree = self.branch.repository.revision_tree(base_rev_id)
+
+                nb_conflicts = merge.merge_inner(self.branch, to_tree, base_tree,
+                                                 this_tree=self,
+                                                 change_reporter=change_reporter,
+                                                 show_base=show_base)
+                self.set_last_revision(revision)
+                # TODO - dedup parents list with things merged by pull ?
+                # reuse the tree we've updated to to set the basis:
+                parent_trees = [(revision, to_tree)]
+                merges = self.get_parent_ids()[1:]
+                # Ideally we ask the tree for the trees here, that way the working
+                # tree can decide whether to give us the entire tree or give us a
+                # lazy initialised tree. dirstate for instance will have the trees
+                # in ram already, whereas a last-revision + basis-inventory tree
+                # will not, but also does not need them when setting parents.
+                for parent in merges:
+                    parent_trees.append(
+                        (parent, self.branch.repository.revision_tree(parent)))
+                if not _mod_revision.is_null(old_tip):
+                    parent_trees.append(
+                        (old_tip, self.branch.repository.revision_tree(old_tip)))
+                self.set_parent_trees(parent_trees)
+                last_rev = parent_trees[0][0]
+            return nb_conflicts
 
 
 class WorkingTreeFormatMetaDir(bzrdir.BzrFormat, WorkingTreeFormat):

=== modified file 'breezy/bzr/workingtree_3.py'
--- breezy/bzr/workingtree_3.py	2019-06-29 13:16:26 +0000
+++ breezy/bzr/workingtree_3.py	2020-09-02 17:42:36 +0000
@@ -25,6 +25,7 @@
 from . import (
     bzrdir,
     inventory,
+    transform as bzr_transform,
     )
 
 from .. import (
@@ -33,7 +34,6 @@
     osutils,
     revision as _mod_revision,
     trace,
-    transform,
     )
 from ..lockable_files import LockableFiles
 from ..lockdir import LockDir
@@ -230,7 +230,7 @@
                 wt.set_parent_trees([])
             else:
                 wt.set_parent_trees([(revision_id, basis_tree)])
-            transform.build_tree(basis_tree, wt)
+            bzr_transform.build_tree(basis_tree, wt)
             for hook in MutableTree.hooks['post_build_tree']:
                 hook(wt)
         finally:

=== modified file 'breezy/bzr/workingtree_4.py'
--- breezy/bzr/workingtree_4.py	2020-08-15 12:10:03 +0000
+++ breezy/bzr/workingtree_4.py	2020-09-02 17:42:36 +0000
@@ -43,12 +43,12 @@
     revision as _mod_revision,
     revisiontree,
     trace,
-    transform,
     views,
     )
 from breezy.bzr import (
     dirstate,
     generate_ids,
+    transform as bzr_transform,
     )
 """)
 
@@ -1577,9 +1577,10 @@
                 # delta_from_tree is safe even for DirStateRevisionTrees,
                 # because wt4.apply_inventory_delta does not mutate the input
                 # inventory entries.
-                transform.build_tree(basis, wt, accelerator_tree,
-                                     hardlink=hardlink,
-                                     delta_from_tree=delta_from_tree)
+                bzr_transform.build_tree(
+                    basis, wt, accelerator_tree,
+                    hardlink=hardlink,
+                    delta_from_tree=delta_from_tree)
                 for hook in MutableTree.hooks['post_build_tree']:
                     hook(wt)
         finally:

=== modified file 'breezy/git/tests/__init__.py'
--- breezy/git/tests/__init__.py	2020-06-21 22:00:40 +0000
+++ breezy/git/tests/__init__.py	2020-09-02 17:42:36 +0000
@@ -229,6 +229,7 @@
         'test_revspec',
         'test_roundtrip',
         'test_server',
+        'test_transform',
         'test_transportgit',
         'test_tree',
         'test_unpeel_map',

=== modified file 'breezy/git/tests/test_blackbox.py'
--- breezy/git/tests/test_blackbox.py	2020-03-22 20:02:36 +0000
+++ breezy/git/tests/test_blackbox.py	2020-09-02 17:42:36 +0000
@@ -177,6 +177,20 @@
             error,
             'Pushed up to revision id git(.*).\n')
 
+    def test_merge(self):
+        self.run_bzr(['init', '--git', 'orig'])
+        self.build_tree_contents([('orig/a', 'orig contents\n')])
+        self.run_bzr(['add', 'orig/a'])
+        self.run_bzr(['commit', '-m', 'add orig', 'orig'])
+        self.run_bzr(['clone', 'orig', 'other'])
+        self.build_tree_contents([('other/a', 'new contents\n')])
+        self.run_bzr(['commit', '-m', 'modify', 'other'])
+        self.build_tree_contents([('orig/b', 'more\n')])
+        self.run_bzr(['add', 'orig/b'])
+        self.build_tree_contents([('orig/a', 'new contents\n')])
+        self.run_bzr(['commit', '-m', 'more', 'orig'])
+        self.run_bzr(['merge', '-d', 'orig', 'other'])
+
     def test_push_lossy_non_mainline(self):
         self.run_bzr(['init', '--git', 'bla'])
         self.run_bzr(['init', 'foo'])

=== added file 'breezy/git/tests/test_transform.py'
--- breezy/git/tests/test_transform.py	1970-01-01 00:00:00 +0000
+++ breezy/git/tests/test_transform.py	2020-09-02 17:42:36 +0000
@@ -0,0 +1,41 @@
+# Copyright (C) 2020 Jelmer Vernooij <[e-mail]>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
+"""Tests for tree transform."""
+
+from __future__ import absolute_import
+
+import os
+
+from ...transform import ROOT_PARENT, conflict_pass, resolve_conflicts
+from . import TestCaseWithTransport
+
+
+class GitTransformTests(TestCaseWithTransport):
+
+    def test_directory_exists(self):
+        tree = self.make_branch_and_tree('.', format='git')
+        tt = tree.transform()
+        dir1 = tt.new_directory('dir', ROOT_PARENT)
+        tt.new_file('name1', dir1, [b'content1'])
+        dir2 = tt.new_directory('dir', ROOT_PARENT)
+        tt.new_file('name2', dir2, [b'content2'])
+        raw_conflicts = resolve_conflicts(
+            tt, None, lambda t, c: conflict_pass(t, c))
+        conflicts = tt.cook_conflicts(raw_conflicts)
+        self.assertEqual([], list(conflicts))
+        tt.apply()
+        self.assertEqual(set(['name1', 'name2']), set(os.listdir('dir')))

=== modified file 'breezy/git/transform.py'
--- breezy/git/transform.py	2020-08-22 15:44:15 +0000
+++ breezy/git/transform.py	2020-09-02 17:42:36 +0000
@@ -301,7 +301,6 @@
 
     def _parent_loops(self):
         """No entry should be its own ancestor"""
-        conflicts = []
         for trans_id in self._new_parent:
             seen = set()
             parent_id = trans_id
@@ -312,28 +311,25 @@
                 except KeyError:
                     break
                 if parent_id == trans_id:
-                    conflicts.append(('parent loop', trans_id))
+                    yield ('parent loop', trans_id)
                 if parent_id in seen:
                     break
-        return conflicts
 
     def _improper_versioning(self):
         """Cannot version a file with no contents, or a bad type.
 
         However, existing entries with no contents are okay.
         """
-        conflicts = []
         for trans_id in self._versioned:
             kind = self.final_kind(trans_id)
             if kind == 'symlink' and not self._tree.supports_symlinks():
                 # Ignore symlinks as they are not supported on this platform
                 continue
             if kind is None:
-                conflicts.append(('versioning no contents', trans_id))
+                yield ('versioning no contents', trans_id)
                 continue
             if not self._tree.versionable_kind(kind):
-                conflicts.append(('versioning bad kind', trans_id, kind))
-        return conflicts
+                yield ('versioning bad kind', trans_id, kind)
 
     def _executability_conflicts(self):
         """Check for bad executability changes.
@@ -343,31 +339,25 @@
         2. only files can be executable.  (The execute bit on a directory
            does not indicate searchability)
         """
-        conflicts = []
         for trans_id in self._new_executability:
             if not self.final_is_versioned(trans_id):
-                conflicts.append(('unversioned executability', trans_id))
+                yield ('unversioned executability', trans_id)
             else:
                 if self.final_kind(trans_id) != "file":
-                    conflicts.append(('non-file executability', trans_id))
-        return conflicts
+                    yield ('non-file executability', trans_id)
 
     def _overwrite_conflicts(self):
         """Check for overwrites (not permitted on Win32)"""
-        conflicts = []
         for trans_id in self._new_contents:
             if self.tree_kind(trans_id) is None:
                 continue
             if trans_id not in self._removed_contents:
-                conflicts.append(('overwrite', trans_id,
-                                  self.final_name(trans_id)))
-        return conflicts
+                yield ('overwrite', trans_id, self.final_name(trans_id))
 
     def _duplicate_entries(self, by_parent):
         """No directory may have two entries with the same name."""
-        conflicts = []
         if (self._new_name, self._new_parent) == ({}, {}):
-            return conflicts
+            return
         for children in viewvalues(by_parent):
             name_ids = []
             for child_tid in children:
@@ -385,15 +375,12 @@
                 if kind is None and not self.final_is_versioned(trans_id):
                     continue
                 if name == last_name:
-                    conflicts.append(('duplicate', last_trans_id, trans_id,
-                                      name))
+                    yield ('duplicate', last_trans_id, trans_id, name)
                 last_name = name
                 last_trans_id = trans_id
-        return conflicts
 
     def _parent_type_conflicts(self, by_parent):
         """Children must have a directory parent"""
-        conflicts = []
         for parent_id, children in viewitems(by_parent):
             if parent_id == ROOT_PARENT:
                 continue
@@ -409,11 +396,10 @@
             kind = self.final_kind(parent_id)
             if kind is None:
                 # The directory will be deleted
-                conflicts.append(('missing parent', parent_id))
+                yield ('missing parent', parent_id)
             elif kind != "directory":
                 # Meh, we need a *directory* to put something in it
-                conflicts.append(('non-directory parent', parent_id))
-        return conflicts
+                yield ('non-directory parent', parent_id)
 
     def _set_executability(self, path, trans_id):
         """Set the executability of versioned files """
@@ -746,7 +732,7 @@
         """Cancel the creation of new file contents."""
         raise NotImplementedError(self.cancel_creation)
 
-    def apply(self, no_conflicts=False, precomputed_delta=None, _mover=None):
+    def apply(self, no_conflicts=False, _mover=None):
         """Apply all changes to the inventory and filesystem.
 
         If filesystem or inventory conflicts are present, MalformedTransform
@@ -756,8 +742,6 @@
 
         :param no_conflicts: if True, the caller guarantees there are no
             conflicts, so no check is made.
-        :param precomputed_delta: An inventory delta to use instead of
-            calculating one.
         :param _mover: Supply an alternate FileMover, for testing
         """
         raise NotImplementedError(self.apply)

=== modified file 'breezy/git/workingtree.py'
--- breezy/git/workingtree.py	2020-08-16 22:04:52 +0000
+++ breezy/git/workingtree.py	2020-09-02 17:42:36 +0000
@@ -1451,6 +1451,132 @@
         config.write_to_path(path)
         self.add('.gitmodules')
 
+    _marker = object()
+
+    def update(self, change_reporter=None, possible_transports=None,
+               revision=None, old_tip=_marker, show_base=False):
+        """Update a working tree along its branch.
+
+        This will update the branch if its bound too, which means we have
+        multiple trees involved:
+
+        - The new basis tree of the master.
+        - The old basis tree of the branch.
+        - The old basis tree of the working tree.
+        - The current working tree state.
+
+        Pathologically, all three may be different, and non-ancestors of each
+        other.  Conceptually we want to:
+
+        - Preserve the wt.basis->wt.state changes
+        - Transform the wt.basis to the new master basis.
+        - Apply a merge of the old branch basis to get any 'local' changes from
+          it into the tree.
+        - Restore the wt.basis->wt.state changes.
+
+        There isn't a single operation at the moment to do that, so we:
+
+        - Merge current state -> basis tree of the master w.r.t. the old tree
+          basis.
+        - Do a 'normal' merge of the old branch basis if it is relevant.
+
+        :param revision: The target revision to update to. Must be in the
+            revision history.
+        :param old_tip: If branch.update() has already been run, the value it
+            returned (old tip of the branch or None). _marker is used
+            otherwise.
+        """
+        if self.branch.get_bound_location() is not None:
+            self.lock_write()
+            update_branch = (old_tip is self._marker)
+        else:
+            self.lock_tree_write()
+            update_branch = False
+        try:
+            if update_branch:
+                old_tip = self.branch.update(possible_transports)
+            else:
+                if old_tip is self._marker:
+                    old_tip = None
+            return self._update_tree(old_tip, change_reporter, revision, show_base)
+        finally:
+            self.unlock()
+
+    def _update_tree(self, old_tip=None, change_reporter=None, revision=None,
+                     show_base=False):
+        """Update a tree to the master branch.
+
+        :param old_tip: if supplied, the previous tip revision the branch,
+            before it was changed to the master branch's tip.
+        """
+        # here if old_tip is not None, it is the old tip of the branch before
+        # it was updated from the master branch. This should become a pending
+        # merge in the working tree to preserve the user existing work.  we
+        # cant set that until we update the working trees last revision to be
+        # one from the new branch, because it will just get absorbed by the
+        # parent de-duplication logic.
+        #
+        # We MUST save it even if an error occurs, because otherwise the users
+        # local work is unreferenced and will appear to have been lost.
+        #
+        with self.lock_tree_write():
+            from .. import merge
+            nb_conflicts = 0
+            try:
+                last_rev = self.get_parent_ids()[0]
+            except IndexError:
+                last_rev = _mod_revision.NULL_REVISION
+            if revision is None:
+                revision = self.branch.last_revision()
+
+            old_tip = old_tip or _mod_revision.NULL_REVISION
+
+            if not _mod_revision.is_null(old_tip) and old_tip != last_rev:
+                # the branch we are bound to was updated
+                # merge those changes in first
+                base_tree = self.basis_tree()
+                other_tree = self.branch.repository.revision_tree(old_tip)
+                nb_conflicts = merge.merge_inner(self.branch, other_tree,
+                                                 base_tree, this_tree=self,
+                                                 change_reporter=change_reporter,
+                                                 show_base=show_base)
+                if nb_conflicts:
+                    self.add_parent_tree((old_tip, other_tree))
+                    return nb_conflicts
+
+            if last_rev != _mod_revision.ensure_null(revision):
+                to_tree = self.branch.repository.revision_tree(revision)
+
+                # determine the branch point
+                graph = self.branch.repository.get_graph()
+                base_rev_id = graph.find_unique_lca(self.branch.last_revision(),
+                                                    last_rev)
+                base_tree = self.branch.repository.revision_tree(base_rev_id)
+
+                nb_conflicts = merge.merge_inner(self.branch, to_tree, base_tree,
+                                                 this_tree=self,
+                                                 change_reporter=change_reporter,
+                                                 show_base=show_base)
+                self.set_last_revision(revision)
+                # TODO - dedup parents list with things merged by pull ?
+                # reuse the tree we've updated to to set the basis:
+                parent_trees = [(revision, to_tree)]
+                merges = self.get_parent_ids()[1:]
+                # Ideally we ask the tree for the trees here, that way the working
+                # tree can decide whether to give us the entire tree or give us a
+                # lazy initialised tree. dirstate for instance will have the trees
+                # in ram already, whereas a last-revision + basis-inventory tree
+                # will not, but also does not need them when setting parents.
+                for parent in merges:
+                    parent_trees.append(
+                        (parent, self.branch.repository.revision_tree(parent)))
+                if not _mod_revision.is_null(old_tip):
+                    parent_trees.append(
+                        (old_tip, self.branch.repository.revision_tree(old_tip)))
+                self.set_parent_trees(parent_trees)
+                last_rev = parent_trees[0][0]
+            return nb_conflicts
+
 
 class GitWorkingTreeFormat(workingtree.WorkingTreeFormat):
 

=== modified file 'breezy/plugins/weave_fmt/workingtree.py'
--- breezy/plugins/weave_fmt/workingtree.py	2020-08-09 18:10:01 +0000
+++ breezy/plugins/weave_fmt/workingtree.py	2020-09-02 17:42:36 +0000
@@ -25,11 +25,11 @@
     lock,
     osutils,
     revision as _mod_revision,
-    transform,
     )
 from ...bzr import (
     conflicts as _mod_bzr_conflicts,
     inventory,
+    transform as bzr_transform,
     xml5,
     )
 from ...mutabletree import MutableTree
@@ -117,7 +117,7 @@
         else:
             parent_trees = [(revision_id, basis_tree)]
         wt.set_parent_trees(parent_trees)
-        transform.build_tree(basis_tree, wt)
+        bzr_transform.build_tree(basis_tree, wt)
         for hook in MutableTree.hooks['post_build_tree']:
             hook(wt)
         return wt

=== modified file 'breezy/tests/per_tree/__init__.py'
--- breezy/tests/per_tree/__init__.py	2020-07-05 13:18:03 +0000
+++ breezy/tests/per_tree/__init__.py	2020-09-02 17:42:36 +0000
@@ -26,6 +26,7 @@
 """
 
 from breezy import (
+    cleanup,
     errors,
     tests,
     transform,
@@ -83,7 +84,9 @@
     tree.lock_read()
     testcase.addCleanup(tree.unlock)
     pp = None
-    transform._prepare_revert_transform(basis, tree, tt, None, False, None,
+    es = cleanup.ExitStack()
+    testcase.addCleanup(es.close)
+    transform._prepare_revert_transform(es, basis, tree, tt, None, False, None,
                                         basis, {})
     preview_tree = tt.get_preview_tree()
     preview_tree.set_parent_ids(tree.get_parent_ids())

=== modified file 'breezy/tests/per_workingtree/test_transform.py'
--- breezy/tests/per_workingtree/test_transform.py	2020-08-20 19:27:00 +0000
+++ breezy/tests/per_workingtree/test_transform.py	2020-09-02 17:42:36 +0000
@@ -64,7 +64,6 @@
     create_from_tree,
     FinalPaths,
     resolve_conflicts,
-    resolve_checkout,
     ROOT_PARENT,
     ImmortalLimbo,
     MalformedTransform,
@@ -74,6 +73,7 @@
 )
 
 from breezy.bzr.inventorytree import InventoryTreeChange
+from breezy.bzr.transform import resolve_checkout
 
 from breezy.tests.per_workingtree import TestCaseWithWorkingTree
 

=== modified file 'breezy/tests/test_transform.py'
--- breezy/tests/test_transform.py	2020-08-09 18:10:01 +0000
+++ breezy/tests/test_transform.py	2020-09-02 17:42:36 +0000
@@ -75,12 +75,10 @@
     SymlinkFeature,
     )
 from ..transform import (
-    build_tree,
     create_from_tree,
     _FileMover,
     FinalPaths,
     resolve_conflicts,
-    resolve_checkout,
     ROOT_PARENT,
     ImmortalLimbo,
     MalformedTransform,
@@ -301,410 +299,6 @@
         self.assertEqual(this.wt.id2path(b'i'), pathjoin('b/i1.OTHER'))
 
 
-class TestBuildTree(tests.TestCaseWithTransport):
-
-    def test_build_tree_with_symlinks(self):
-        self.requireFeature(SymlinkFeature)
-        os.mkdir('a')
-        a = ControlDir.create_standalone_workingtree('a')
-        os.mkdir('a/foo')
-        with open('a/foo/bar', 'wb') as f:
-            f.write(b'contents')
-        os.symlink('a/foo/bar', 'a/foo/baz')
-        a.add(['foo', 'foo/bar', 'foo/baz'])
-        a.commit('initial commit')
-        b = ControlDir.create_standalone_workingtree('b')
-        basis = a.basis_tree()
-        basis.lock_read()
-        self.addCleanup(basis.unlock)
-        build_tree(basis, b)
-        self.assertIs(os.path.isdir('b/foo'), True)
-        with open('b/foo/bar', 'rb') as f:
-            self.assertEqual(f.read(), b"contents")
-        self.assertEqual(os.readlink('b/foo/baz'), 'a/foo/bar')
-
-    def test_build_with_references(self):
-        tree = self.make_branch_and_tree('source',
-                                         format='development-subtree')
-        subtree = self.make_branch_and_tree('source/subtree',
-                                            format='development-subtree')
-        tree.add_reference(subtree)
-        tree.commit('a revision')
-        tree.branch.create_checkout('target')
-        self.assertPathExists('target')
-        self.assertPathExists('target/subtree')
-
-    def test_file_conflict_handling(self):
-        """Ensure that when building trees, conflict handling is done"""
-        source = self.make_branch_and_tree('source')
-        target = self.make_branch_and_tree('target')
-        self.build_tree(['source/file', 'target/file'])
-        source.add('file', b'new-file')
-        source.commit('added file')
-        build_tree(source.basis_tree(), target)
-        self.assertEqual(
-            [DuplicateEntry('Moved existing file to', 'file.moved',
-                            'file', None, 'new-file')],
-            target.conflicts())
-        target2 = self.make_branch_and_tree('target2')
-        with open('target2/file', 'wb') as target_file, \
-                open('source/file', 'rb') as source_file:
-            target_file.write(source_file.read())
-        build_tree(source.basis_tree(), target2)
-        self.assertEqual([], target2.conflicts())
-
-    def test_symlink_conflict_handling(self):
-        """Ensure that when building trees, conflict handling is done"""
-        self.requireFeature(SymlinkFeature)
-        source = self.make_branch_and_tree('source')
-        os.symlink('foo', 'source/symlink')
-        source.add('symlink', b'new-symlink')
-        source.commit('added file')
-        target = self.make_branch_and_tree('target')
-        os.symlink('bar', 'target/symlink')
-        build_tree(source.basis_tree(), target)
-        self.assertEqual(
-            [DuplicateEntry('Moved existing file to', 'symlink.moved',
-                            'symlink', None, 'new-symlink')],
-            target.conflicts())
-        target = self.make_branch_and_tree('target2')
-        os.symlink('foo', 'target2/symlink')
-        build_tree(source.basis_tree(), target)
-        self.assertEqual([], target.conflicts())
-
-    def test_directory_conflict_handling(self):
-        """Ensure that when building trees, conflict handling is done"""
-        source = self.make_branch_and_tree('source')
-        target = self.make_branch_and_tree('target')
-        self.build_tree(['source/dir1/', 'source/dir1/file', 'target/dir1/'])
-        source.add(['dir1', 'dir1/file'], [b'new-dir1', b'new-file'])
-        source.commit('added file')
-        build_tree(source.basis_tree(), target)
-        self.assertEqual([], target.conflicts())
-        self.assertPathExists('target/dir1/file')
-
-        # Ensure contents are merged
-        target = self.make_branch_and_tree('target2')
-        self.build_tree(['target2/dir1/', 'target2/dir1/file2'])
-        build_tree(source.basis_tree(), target)
-        self.assertEqual([], target.conflicts())
-        self.assertPathExists('target2/dir1/file2')
-        self.assertPathExists('target2/dir1/file')
-
-        # Ensure new contents are suppressed for existing branches
-        target = self.make_branch_and_tree('target3')
-        self.make_branch('target3/dir1')
-        self.build_tree(['target3/dir1/file2'])
-        build_tree(source.basis_tree(), target)
-        self.assertPathDoesNotExist('target3/dir1/file')
-        self.assertPathExists('target3/dir1/file2')
-        self.assertPathExists('target3/dir1.diverted/file')
-        self.assertEqual(
-            [DuplicateEntry('Diverted to', 'dir1.diverted',
-                            'dir1', 'new-dir1', None)],
-            target.conflicts())
-
-        target = self.make_branch_and_tree('target4')
-        self.build_tree(['target4/dir1/'])
-        self.make_branch('target4/dir1/file')
-        build_tree(source.basis_tree(), target)
-        self.assertPathExists('target4/dir1/file')
-        self.assertEqual('directory', file_kind('target4/dir1/file'))
-        self.assertPathExists('target4/dir1/file.diverted')
-        self.assertEqual(
-            [DuplicateEntry('Diverted to', 'dir1/file.diverted',
-                            'dir1/file', 'new-file', None)],
-            target.conflicts())
-
-    def test_mixed_conflict_handling(self):
-        """Ensure that when building trees, conflict handling is done"""
-        source = self.make_branch_and_tree('source')
-        target = self.make_branch_and_tree('target')
-        self.build_tree(['source/name', 'target/name/'])
-        source.add('name', b'new-name')
-        source.commit('added file')
-        build_tree(source.basis_tree(), target)
-        self.assertEqual(
-            [DuplicateEntry('Moved existing file to',
-                            'name.moved', 'name', None, 'new-name')],
-            target.conflicts())
-
-    def test_raises_in_populated(self):
-        source = self.make_branch_and_tree('source')
-        self.build_tree(['source/name'])
-        source.add('name')
-        source.commit('added name')
-        target = self.make_branch_and_tree('target')
-        self.build_tree(['target/name'])
-        target.add('name')
-        self.assertRaises(errors.WorkingTreeAlreadyPopulated,
-                          build_tree, source.basis_tree(), target)
-
-    def test_build_tree_rename_count(self):
-        source = self.make_branch_and_tree('source')
-        self.build_tree(['source/file1', 'source/dir1/'])
-        source.add(['file1', 'dir1'])
-        source.commit('add1')
-        target1 = self.make_branch_and_tree('target1')
-        transform_result = build_tree(source.basis_tree(), target1)
-        self.assertEqual(2, transform_result.rename_count)
-
-        self.build_tree(['source/dir1/file2'])
-        source.add(['dir1/file2'])
-        source.commit('add3')
-        target2 = self.make_branch_and_tree('target2')
-        transform_result = build_tree(source.basis_tree(), target2)
-        # children of non-root directories should not be renamed
-        self.assertEqual(2, transform_result.rename_count)
-
-    def create_ab_tree(self):
-        """Create a committed test tree with two files"""
-        source = self.make_branch_and_tree('source')
-        self.build_tree_contents([('source/file1', b'A')])
-        self.build_tree_contents([('source/file2', b'B')])
-        source.add(['file1', 'file2'], [b'file1-id', b'file2-id'])
-        source.commit('commit files')
-        source.lock_write()
-        self.addCleanup(source.unlock)
-        return source
-
-    def test_build_tree_accelerator_tree(self):
-        source = self.create_ab_tree()
-        self.build_tree_contents([('source/file2', b'C')])
-        calls = []
-        real_source_get_file = source.get_file
-
-        def get_file(path):
-            calls.append(path)
-            return real_source_get_file(path)
-        source.get_file = get_file
-        target = self.make_branch_and_tree('target')
-        revision_tree = source.basis_tree()
-        revision_tree.lock_read()
-        self.addCleanup(revision_tree.unlock)
-        build_tree(revision_tree, target, source)
-        self.assertEqual(['file1'], calls)
-        target.lock_read()
-        self.addCleanup(target.unlock)
-        self.assertEqual([], list(target.iter_changes(revision_tree)))
-
-    def test_build_tree_accelerator_tree_observes_sha1(self):
-        source = self.create_ab_tree()
-        sha1 = osutils.sha_string(b'A')
-        target = self.make_branch_and_tree('target')
-        target.lock_write()
-        self.addCleanup(target.unlock)
-        state = target.current_dirstate()
-        state._cutoff_time = time.time() + 60
-        build_tree(source.basis_tree(), target, source)
-        entry = state._get_entry(0, path_utf8=b'file1')
-        self.assertEqual(sha1, entry[1][0][1])
-
-    def test_build_tree_accelerator_tree_missing_file(self):
-        source = self.create_ab_tree()
-        os.unlink('source/file1')
-        source.remove(['file2'])
-        target = self.make_branch_and_tree('target')
-        revision_tree = source.basis_tree()
-        revision_tree.lock_read()
-        self.addCleanup(revision_tree.unlock)
-        build_tree(revision_tree, target, source)
-        target.lock_read()
-        self.addCleanup(target.unlock)
-        self.assertEqual([], list(target.iter_changes(revision_tree)))
-
-    def test_build_tree_accelerator_wrong_kind(self):
-        self.requireFeature(SymlinkFeature)
-        source = self.make_branch_and_tree('source')
-        self.build_tree_contents([('source/file1', b'')])
-        self.build_tree_contents([('source/file2', b'')])
-        source.add(['file1', 'file2'], [b'file1-id', b'file2-id'])
-        source.commit('commit files')
-        os.unlink('source/file2')
-        self.build_tree_contents([('source/file2/', b'C')])
-        os.unlink('source/file1')
-        os.symlink('file2', 'source/file1')
-        calls = []
-        real_source_get_file = source.get_file
-
-        def get_file(path):
-            calls.append(path)
-            return real_source_get_file(path)
-        source.get_file = get_file
-        target = self.make_branch_and_tree('target')
-        revision_tree = source.basis_tree()
-        revision_tree.lock_read()
-        self.addCleanup(revision_tree.unlock)
-        build_tree(revision_tree, target, source)
-        self.assertEqual([], calls)
-        target.lock_read()
-        self.addCleanup(target.unlock)
-        self.assertEqual([], list(target.iter_changes(revision_tree)))
-
-    def test_build_tree_hardlink(self):
-        self.requireFeature(HardlinkFeature)
-        source = self.create_ab_tree()
-        target = self.make_branch_and_tree('target')
-        revision_tree = source.basis_tree()
-        revision_tree.lock_read()
-        self.addCleanup(revision_tree.unlock)
-        build_tree(revision_tree, target, source, hardlink=True)
-        target.lock_read()
-        self.addCleanup(target.unlock)
-        self.assertEqual([], list(target.iter_changes(revision_tree)))
-        source_stat = os.stat('source/file1')
-        target_stat = os.stat('target/file1')
-        self.assertEqual(source_stat, target_stat)
-
-        # Explicitly disallowing hardlinks should prevent them.
-        target2 = self.make_branch_and_tree('target2')
-        build_tree(revision_tree, target2, source, hardlink=False)
-        target2.lock_read()
-        self.addCleanup(target2.unlock)
-        self.assertEqual([], list(target2.iter_changes(revision_tree)))
-        source_stat = os.stat('source/file1')
-        target2_stat = os.stat('target2/file1')
-        self.assertNotEqual(source_stat, target2_stat)
-
-    def test_build_tree_accelerator_tree_moved(self):
-        source = self.make_branch_and_tree('source')
-        self.build_tree_contents([('source/file1', b'A')])
-        source.add(['file1'], [b'file1-id'])
-        source.commit('commit files')
-        source.rename_one('file1', 'file2')
-        source.lock_read()
-        self.addCleanup(source.unlock)
-        target = self.make_branch_and_tree('target')
-        revision_tree = source.basis_tree()
-        revision_tree.lock_read()
-        self.addCleanup(revision_tree.unlock)
-        build_tree(revision_tree, target, source)
-        target.lock_read()
-        self.addCleanup(target.unlock)
-        self.assertEqual([], list(target.iter_changes(revision_tree)))
-
-    def test_build_tree_hardlinks_preserve_execute(self):
-        self.requireFeature(HardlinkFeature)
-        source = self.create_ab_tree()
-        tt = source.transform()
-        trans_id = tt.trans_id_tree_path('file1')
-        tt.set_executability(True, trans_id)
-        tt.apply()
-        self.assertTrue(source.is_executable('file1'))
-        target = self.make_branch_and_tree('target')
-        revision_tree = source.basis_tree()
-        revision_tree.lock_read()
-        self.addCleanup(revision_tree.unlock)
-        build_tree(revision_tree, target, source, hardlink=True)
-        target.lock_read()
-        self.addCleanup(target.unlock)
-        self.assertEqual([], list(target.iter_changes(revision_tree)))
-        self.assertTrue(source.is_executable('file1'))
-
-    def install_rot13_content_filter(self, pattern):
-        # We could use
-        # self.addCleanup(filters._reset_registry, filters._reset_registry())
-        # below, but that looks a bit... hard to read even if it's exactly
-        # the same thing.
-        original_registry = filters._reset_registry()
-
-        def restore_registry():
-            filters._reset_registry(original_registry)
-        self.addCleanup(restore_registry)
-
-        def rot13(chunks, context=None):
-            return [
-                codecs.encode(chunk.decode('ascii'), 'rot13').encode('ascii')
-                for chunk in chunks]
-        rot13filter = filters.ContentFilter(rot13, rot13)
-        filters.filter_stacks_registry.register(
-            'rot13', {'yes': [rot13filter]}.get)
-        os.mkdir(self.test_home_dir + '/.bazaar')
-        rules_filename = self.test_home_dir + '/.bazaar/rules'
-        with open(rules_filename, 'wb') as f:
-            f.write(b'[name %s]\nrot13=yes\n' % (pattern,))
-
-        def uninstall_rules():
-            os.remove(rules_filename)
-            rules.reset_rules()
-        self.addCleanup(uninstall_rules)
-        rules.reset_rules()
-
-    def test_build_tree_content_filtered_files_are_not_hardlinked(self):
-        """build_tree will not hardlink files that have content filtering rules
-        applied to them (but will still hardlink other files from the same tree
-        if it can).
-        """
-        self.requireFeature(HardlinkFeature)
-        self.install_rot13_content_filter(b'file1')
-        source = self.create_ab_tree()
-        target = self.make_branch_and_tree('target')
-        revision_tree = source.basis_tree()
-        revision_tree.lock_read()
-        self.addCleanup(revision_tree.unlock)
-        build_tree(revision_tree, target, source, hardlink=True)
-        target.lock_read()
-        self.addCleanup(target.unlock)
-        self.assertEqual([], list(target.iter_changes(revision_tree)))
-        source_stat = os.stat('source/file1')
-        target_stat = os.stat('target/file1')
-        self.assertNotEqual(source_stat, target_stat)
-        source_stat = os.stat('source/file2')
-        target_stat = os.stat('target/file2')
-        self.assertEqualStat(source_stat, target_stat)
-
-    def test_case_insensitive_build_tree_inventory(self):
-        if (features.CaseInsensitiveFilesystemFeature.available()
-                or features.CaseInsCasePresFilenameFeature.available()):
-            raise tests.UnavailableFeature('Fully case sensitive filesystem')
-        source = self.make_branch_and_tree('source')
-        self.build_tree(['source/file', 'source/FILE'])
-        source.add(['file', 'FILE'], [b'lower-id', b'upper-id'])
-        source.commit('added files')
-        # Don't try this at home, kids!
-        # Force the tree to report that it is case insensitive
-        target = self.make_branch_and_tree('target')
-        target.case_sensitive = False
-        build_tree(source.basis_tree(), target, source, delta_from_tree=True)
-        self.assertEqual('file.moved', target.id2path(b'lower-id'))
-        self.assertEqual('FILE', target.id2path(b'upper-id'))
-
-    def test_build_tree_observes_sha(self):
-        source = self.make_branch_and_tree('source')
-        self.build_tree(['source/file1', 'source/dir/', 'source/dir/file2'])
-        source.add(['file1', 'dir', 'dir/file2'],
-                   [b'file1-id', b'dir-id', b'file2-id'])
-        source.commit('new files')
-        target = self.make_branch_and_tree('target')
-        target.lock_write()
-        self.addCleanup(target.unlock)
-        # We make use of the fact that DirState caches its cutoff time. So we
-        # set the 'safe' time to one minute in the future.
-        state = target.current_dirstate()
-        state._cutoff_time = time.time() + 60
-        build_tree(source.basis_tree(), target)
-        entry1_sha = osutils.sha_file_by_name('source/file1')
-        entry2_sha = osutils.sha_file_by_name('source/dir/file2')
-        # entry[1] is the state information, entry[1][0] is the state of the
-        # working tree, entry[1][0][1] is the sha value for the current working
-        # tree
-        entry1 = state._get_entry(0, path_utf8=b'file1')
-        self.assertEqual(entry1_sha, entry1[1][0][1])
-        # The 'size' field must also be set.
-        self.assertEqual(25, entry1[1][0][2])
-        entry1_state = entry1[1][0]
-        entry2 = state._get_entry(0, path_utf8=b'dir/file2')
-        self.assertEqual(entry2_sha, entry2[1][0][1])
-        self.assertEqual(29, entry2[1][0][2])
-        entry2_state = entry2[1][0]
-        # Now, make sure that we don't have to re-read the content. The
-        # packed_stat should match exactly.
-        self.assertEqual(entry1_sha, target.get_file_sha1('file1'))
-        self.assertEqual(entry2_sha, target.get_file_sha1('dir/file2'))
-        self.assertEqual(entry1_state, entry1[1][0])
-        self.assertEqual(entry2_state, entry2[1][0])
-
-
 class TestCommitTransform(tests.TestCaseWithTransport):
 
     def get_branch(self):

=== modified file 'breezy/transform.py'
--- breezy/transform.py	2020-08-15 17:47:31 +0000
+++ breezy/transform.py	2020-09-02 17:42:36 +0000
@@ -646,200 +646,6 @@
         return [(self.get_path(t), t) for t in trans_ids]
 
 
-def build_tree(tree, wt, accelerator_tree=None, hardlink=False,
-               delta_from_tree=False):
-    """Create working tree for a branch, using a TreeTransform.
-
-    This function should be used on empty trees, having a tree root at most.
-    (see merge and revert functionality for working with existing trees)
-
-    Existing files are handled like so:
-
-    - Existing bzrdirs take precedence over creating new items.  They are
-      created as '%s.diverted' % name.
-    - Otherwise, if the content on disk matches the content we are building,
-      it is silently replaced.
-    - Otherwise, conflict resolution will move the old file to 'oldname.moved'.
-
-    :param tree: The tree to convert wt into a copy of
-    :param wt: The working tree that files will be placed into
-    :param accelerator_tree: A tree which can be used for retrieving file
-        contents more quickly than tree itself, i.e. a workingtree.  tree
-        will be used for cases where accelerator_tree's content is different.
-    :param hardlink: If true, hard-link files to accelerator_tree, where
-        possible.  accelerator_tree must implement abspath, i.e. be a
-        working tree.
-    :param delta_from_tree: If true, build_tree may use the input Tree to
-        generate the inventory delta.
-    """
-    with cleanup.ExitStack() as exit_stack:
-        exit_stack.enter_context(wt.lock_tree_write())
-        exit_stack.enter_context(tree.lock_read())
-        if accelerator_tree is not None:
-            exit_stack.enter_context(accelerator_tree.lock_read())
-        return _build_tree(tree, wt, accelerator_tree, hardlink,
-                           delta_from_tree)
-
-
-def _build_tree(tree, wt, accelerator_tree, hardlink, delta_from_tree):
-    """See build_tree."""
-    for num, _unused in enumerate(wt.all_versioned_paths()):
-        if num > 0:  # more than just a root
-            raise errors.WorkingTreeAlreadyPopulated(base=wt.basedir)
-    file_trans_id = {}
-    top_pb = ui.ui_factory.nested_progress_bar()
-    pp = ProgressPhase("Build phase", 2, top_pb)
-    if tree.path2id('') is not None:
-        # This is kind of a hack: we should be altering the root
-        # as part of the regular tree shape diff logic.
-        # The conditional test here is to avoid doing an
-        # expensive operation (flush) every time the root id
-        # is set within the tree, nor setting the root and thus
-        # marking the tree as dirty, because we use two different
-        # idioms here: tree interfaces and inventory interfaces.
-        if wt.path2id('') != tree.path2id(''):
-            wt.set_root_id(tree.path2id(''))
-            wt.flush()
-    tt = wt.transform()
-    divert = set()
-    try:
-        pp.next_phase()
-        file_trans_id[find_previous_path(wt, tree, '')] = tt.trans_id_tree_path('')
-        with ui.ui_factory.nested_progress_bar() as pb:
-            deferred_contents = []
-            num = 0
-            total = len(tree.all_versioned_paths())
-            if delta_from_tree:
-                precomputed_delta = []
-            else:
-                precomputed_delta = None
-            # Check if tree inventory has content. If so, we populate
-            # existing_files with the directory content. If there are no
-            # entries we skip populating existing_files as its not used.
-            # This improves performance and unncessary work on large
-            # directory trees. (#501307)
-            if total > 0:
-                existing_files = set()
-                for dir, files in wt.walkdirs():
-                    existing_files.update(f[0] for f in files)
-            for num, (tree_path, entry) in \
-                    enumerate(tree.iter_entries_by_dir()):
-                pb.update(gettext("Building tree"), num
-                          - len(deferred_contents), total)
-                if entry.parent_id is None:
-                    continue
-                reparent = False
-                file_id = entry.file_id
-                if delta_from_tree:
-                    precomputed_delta.append((None, tree_path, file_id, entry))
-                if tree_path in existing_files:
-                    target_path = wt.abspath(tree_path)
-                    kind = file_kind(target_path)
-                    if kind == "directory":
-                        try:
-                            controldir.ControlDir.open(target_path)
-                        except errors.NotBranchError:
-                            pass
-                        else:
-                            divert.add(tree_path)
-                    if (tree_path not in divert
-                        and _content_match(
-                            tree, entry, tree_path, kind, target_path)):
-                        tt.delete_contents(tt.trans_id_tree_path(tree_path))
-                        if kind == 'directory':
-                            reparent = True
-                parent_id = file_trans_id[osutils.dirname(tree_path)]
-                if entry.kind == 'file':
-                    # We *almost* replicate new_by_entry, so that we can defer
-                    # getting the file text, and get them all at once.
-                    trans_id = tt.create_path(entry.name, parent_id)
-                    file_trans_id[tree_path] = trans_id
-                    tt.version_file(trans_id, file_id=file_id)
-                    executable = tree.is_executable(tree_path)
-                    if executable:
-                        tt.set_executability(executable, trans_id)
-                    trans_data = (trans_id, tree_path, entry.text_sha1)
-                    deferred_contents.append((tree_path, trans_data))
-                else:
-                    file_trans_id[tree_path] = new_by_entry(
-                        tree_path, tt, entry, parent_id, tree)
-                if reparent:
-                    new_trans_id = file_trans_id[tree_path]
-                    old_parent = tt.trans_id_tree_path(tree_path)
-                    _reparent_children(tt, old_parent, new_trans_id)
-            offset = num + 1 - len(deferred_contents)
-            _create_files(tt, tree, deferred_contents, pb, offset,
-                          accelerator_tree, hardlink)
-        pp.next_phase()
-        divert_trans = set(file_trans_id[f] for f in divert)
-
-        def resolver(t, c):
-            return resolve_checkout(t, c, divert_trans)
-        raw_conflicts = resolve_conflicts(tt, pass_func=resolver)
-        if len(raw_conflicts) > 0:
-            precomputed_delta = None
-        conflicts = tt.cook_conflicts(raw_conflicts)
-        for conflict in conflicts:
-            trace.warning(text_type(conflict))
-        try:
-            wt.add_conflicts(conflicts)
-        except errors.UnsupportedOperation:
-            pass
-        result = tt.apply(no_conflicts=True,
-                          precomputed_delta=precomputed_delta)
-    finally:
-        tt.finalize()
-        top_pb.finished()
-    return result
-
-
-def _create_files(tt, tree, desired_files, pb, offset, accelerator_tree,
-                  hardlink):
-    total = len(desired_files) + offset
-    wt = tt._tree
-    if accelerator_tree is None:
-        new_desired_files = desired_files
-    else:
-        iter = accelerator_tree.iter_changes(tree, include_unchanged=True)
-        unchanged = [
-            change.path for change in iter
-            if not (change.changed_content or change.executable[0] != change.executable[1])]
-        if accelerator_tree.supports_content_filtering():
-            unchanged = [(tp, ap) for (tp, ap) in unchanged
-                         if not next(accelerator_tree.iter_search_rules([ap]))]
-        unchanged = dict(unchanged)
-        new_desired_files = []
-        count = 0
-        for unused_tree_path, (trans_id, tree_path, text_sha1) in desired_files:
-            accelerator_path = unchanged.get(tree_path)
-            if accelerator_path is None:
-                new_desired_files.append((tree_path,
-                                          (trans_id, tree_path, text_sha1)))
-                continue
-            pb.update(gettext('Adding file contents'), count + offset, total)
-            if hardlink:
-                tt.create_hardlink(accelerator_tree.abspath(accelerator_path),
-                                   trans_id)
-            else:
-                with accelerator_tree.get_file(accelerator_path) as f:
-                    chunks = osutils.file_iterator(f)
-                    if wt.supports_content_filtering():
-                        filters = wt._content_filter_stack(tree_path)
-                        chunks = filtered_output_bytes(chunks, filters,
-                                                       ContentFilterContext(tree_path, tree))
-                    tt.create_file(chunks, trans_id, sha1=text_sha1)
-            count += 1
-        offset += count
-    for count, ((trans_id, tree_path, text_sha1), contents) in enumerate(
-            tree.iter_files_bytes(new_desired_files)):
-        if wt.supports_content_filtering():
-            filters = wt._content_filter_stack(tree_path)
-            contents = filtered_output_bytes(contents, filters,
-                                             ContentFilterContext(tree_path, tree))
-        tt.create_file(contents, trans_id, sha1=text_sha1)
-        pb.update(gettext('Adding file contents'), count + offset, total)
-
-
 def _reparent_children(tt, old_parent, new_parent):
     for child in tt.iter_tree_children(old_parent):
         tt.adjust_path(tt.final_name(child), new_parent, child)
@@ -852,52 +658,6 @@
     return by_parent[old_parent]
 
 
-def _content_match(tree, entry, tree_path, kind, target_path):
-    if entry.kind != kind:
-        return False
-    if entry.kind == "directory":
-        return True
-    if entry.kind == "file":
-        with open(target_path, 'rb') as f1, \
-                tree.get_file(tree_path) as f2:
-            if osutils.compare_files(f1, f2):
-                return True
-    elif entry.kind == "symlink":
-        if tree.get_symlink_target(tree_path) == os.readlink(target_path):
-            return True
-    return False
-
-
-def resolve_checkout(tt, conflicts, divert):
-    new_conflicts = set()
-    for c_type, conflict in ((c[0], c) for c in conflicts):
-        # Anything but a 'duplicate' would indicate programmer error
-        if c_type != 'duplicate':
-            raise AssertionError(c_type)
-        # Now figure out which is new and which is old
-        if tt.new_contents(conflict[1]):
-            new_file = conflict[1]
-            old_file = conflict[2]
-        else:
-            new_file = conflict[2]
-            old_file = conflict[1]
-
-        # We should only get here if the conflict wasn't completely
-        # resolved
-        final_parent = tt.final_parent(old_file)
-        if new_file in divert:
-            new_name = tt.final_name(old_file) + '.diverted'
-            tt.adjust_path(new_name, final_parent, new_file)
-            new_conflicts.add((c_type, 'Diverted to',
-                               new_file, old_file))
-        else:
-            new_name = tt.final_name(old_file) + '.moved'
-            tt.adjust_path(new_name, final_parent, old_file)
-            new_conflicts.add((c_type, 'Moved existing file to',
-                               old_file, new_file))
-    return new_conflicts
-
-
 def new_by_entry(path, tt, entry, parent_id, tree):
     """Create a new file according to its inventory entry"""
     name = entry.name
@@ -960,38 +720,13 @@
         tt.set_executability(entry.executable, trans_id)
 
 
-def revert(working_tree, target_tree, filenames, backups=False,
-           pb=None, change_reporter=None):
-    """Revert a working tree's contents to those of a target tree."""
-    pb = ui.ui_factory.nested_progress_bar()
-    try:
-        with target_tree.lock_read(), working_tree.transform(pb) as tt:
-            pp = ProgressPhase("Revert phase", 3, pb)
-            conflicts, merge_modified = _prepare_revert_transform(
-                working_tree, target_tree, tt, filenames, backups, pp)
-            if change_reporter:
-                from . import delta
-                change_reporter = delta._ChangeReporter(
-                    unversioned_filter=working_tree.is_ignored)
-                delta.report_changes(tt.iter_changes(), change_reporter)
-            for conflict in conflicts:
-                trace.warning(text_type(conflict))
-            pp.next_phase()
-            tt.apply()
-            if working_tree.supports_merge_modified():
-                working_tree.set_merge_modified(merge_modified)
-    finally:
-        pb.clear()
-    return conflicts
-
-
-def _prepare_revert_transform(working_tree, target_tree, tt, filenames,
+def _prepare_revert_transform(es, working_tree, target_tree, tt, filenames,
                               backups, pp, basis_tree=None,
                               merge_modified=None):
     with ui.ui_factory.nested_progress_bar() as child_pb:
         if merge_modified is None:
             merge_modified = working_tree.merge_modified()
-        merge_modified = _alter_files(working_tree, target_tree, tt,
+        merge_modified = _alter_files(es, working_tree, target_tree, tt,
                                       child_pb, filenames, backups,
                                       merge_modified, basis_tree)
     with ui.ui_factory.nested_progress_bar() as child_pb:
@@ -1001,10 +736,34 @@
     return conflicts, merge_modified
 
 
-def _alter_files(working_tree, target_tree, tt, pb, specific_files,
+def revert(working_tree, target_tree, filenames, backups=False,
+           pb=None, change_reporter=None, merge_modified=None, basis_tree=None):
+    """Revert a working tree's contents to those of a target tree."""
+    with cleanup.ExitStack() as es:
+        pb = es.enter_context(ui.ui_factory.nested_progress_bar())
+        es.enter_context(target_tree.lock_read())
+        tt = es.enter_context(working_tree.transform(pb))
+        pp = ProgressPhase("Revert phase", 3, pb)
+        conflicts, merge_modified = _prepare_revert_transform(
+            es, working_tree, target_tree, tt, filenames, backups, pp)
+        if change_reporter:
+            from . import delta
+            change_reporter = delta._ChangeReporter(
+                unversioned_filter=working_tree.is_ignored)
+            delta.report_changes(tt.iter_changes(), change_reporter)
+        for conflict in conflicts:
+            trace.warning(text_type(conflict))
+        pp.next_phase()
+        tt.apply()
+        if working_tree.supports_merge_modified():
+            working_tree.set_merge_modified(merge_modified)
+    return conflicts
+
+
+def _alter_files(es, working_tree, target_tree, tt, pb, specific_files,
                  backups, merge_modified, basis_tree=None):
     if basis_tree is not None:
-        basis_tree.lock_read()
+        es.enter_context(basis_tree.lock_read())
     # We ask the working_tree for its changes relative to the target, rather
     # than the target changes relative to the working tree. Because WT4 has an
     # optimizer to compare itself to a target, but no optimizer for the
@@ -1015,123 +774,122 @@
         skip_root = True
     else:
         skip_root = False
-    try:
-        deferred_files = []
-        for id_num, change in enumerate(change_list):
-            target_path, wt_path = change.path
-            target_versioned, wt_versioned = change.versioned
-            target_parent = change.parent_id[0]
-            target_name, wt_name = change.name
-            target_kind, wt_kind = change.kind
-            target_executable, wt_executable = change.executable
-            if skip_root and wt_path == '':
-                continue
-            trans_id = tt.trans_id_file_id(change.file_id)
-            mode_id = None
-            if change.changed_content:
-                keep_content = False
-                if wt_kind == 'file' and (backups or target_kind is None):
-                    wt_sha1 = working_tree.get_file_sha1(wt_path)
-                    if merge_modified.get(wt_path) != wt_sha1:
-                        # acquire the basis tree lazily to prevent the
-                        # expense of accessing it when it's not needed ?
-                        # (Guessing, RBC, 200702)
-                        if basis_tree is None:
-                            basis_tree = working_tree.basis_tree()
-                            basis_tree.lock_read()
-                        basis_inter = InterTree.get(basis_tree, working_tree)
-                        basis_path = basis_inter.find_source_path(wt_path)
-                        if basis_path is None:
-                            if target_kind is None and not target_versioned:
-                                keep_content = True
-                        else:
-                            if wt_sha1 != basis_tree.get_file_sha1(basis_path):
-                                keep_content = True
-                if wt_kind is not None:
-                    if not keep_content:
-                        tt.delete_contents(trans_id)
-                    elif target_kind is not None:
-                        parent_trans_id = tt.trans_id_tree_path(osutils.dirname(wt_path))
-                        backup_name = tt._available_backup_name(
-                            wt_name, parent_trans_id)
-                        tt.adjust_path(backup_name, parent_trans_id, trans_id)
-                        new_trans_id = tt.create_path(wt_name, parent_trans_id)
-                        if wt_versioned and target_versioned:
-                            tt.unversion_file(trans_id)
-                            tt.version_file(
-                                new_trans_id, file_id=getattr(change, 'file_id', None))
-                        # New contents should have the same unix perms as old
-                        # contents
-                        mode_id = trans_id
-                        trans_id = new_trans_id
-                if target_kind in ('directory', 'tree-reference'):
-                    tt.create_directory(trans_id)
-                    if target_kind == 'tree-reference':
-                        revision = target_tree.get_reference_revision(
-                            target_path)
-                        tt.set_tree_reference(revision, trans_id)
-                elif target_kind == 'symlink':
-                    tt.create_symlink(target_tree.get_symlink_target(
-                        target_path), trans_id)
-                elif target_kind == 'file':
-                    deferred_files.append(
-                        (target_path, (trans_id, mode_id, target_path)))
+    deferred_files = []
+    for id_num, change in enumerate(change_list):
+        target_path, wt_path = change.path
+        target_versioned, wt_versioned = change.versioned
+        target_parent = change.parent_id[0]
+        target_name, wt_name = change.name
+        target_kind, wt_kind = change.kind
+        target_executable, wt_executable = change.executable
+        if skip_root and wt_path == '':
+            continue
+        mode_id = None
+        if wt_path is not None:
+            trans_id = tt.trans_id_tree_path(wt_path)
+        else:
+            trans_id = tt.assign_id()
+        if change.changed_content:
+            keep_content = False
+            if wt_kind == 'file' and (backups or target_kind is None):
+                wt_sha1 = working_tree.get_file_sha1(wt_path)
+                if merge_modified.get(wt_path) != wt_sha1:
+                    # acquire the basis tree lazily to prevent the
+                    # expense of accessing it when it's not needed ?
+                    # (Guessing, RBC, 200702)
                     if basis_tree is None:
                         basis_tree = working_tree.basis_tree()
-                        basis_tree.lock_read()
-                    new_sha1 = target_tree.get_file_sha1(target_path)
-                    basis_inter = InterTree.get(basis_tree, target_tree)
-                    basis_path = basis_inter.find_source_path(target_path)
-                    if (basis_path is not None and
-                            new_sha1 == basis_tree.get_file_sha1(basis_path)):
-                        # If the new contents of the file match what is in basis,
-                        # then there is no need to store in merge_modified.
-                        if basis_path in merge_modified:
-                            del merge_modified[basis_path]
+                        es.enter_context(basis_tree.lock_read())
+                    basis_inter = InterTree.get(basis_tree, working_tree)
+                    basis_path = basis_inter.find_source_path(wt_path)
+                    if basis_path is None:
+                        if target_kind is None and not target_versioned:
+                            keep_content = True
                     else:
-                        merge_modified[target_path] = new_sha1
-
-                    # preserve the execute bit when backing up
-                    if keep_content and wt_executable == target_executable:
-                        tt.set_executability(target_executable, trans_id)
+                        if wt_sha1 != basis_tree.get_file_sha1(basis_path):
+                            keep_content = True
+            if wt_kind is not None:
+                if not keep_content:
+                    tt.delete_contents(trans_id)
                 elif target_kind is not None:
-                    raise AssertionError(target_kind)
-            if not wt_versioned and target_versioned:
-                tt.version_file(
-                    trans_id, file_id=getattr(change, 'file_id', None))
-            if wt_versioned and not target_versioned:
-                tt.unversion_file(trans_id)
-            if (target_name is not None
-                    and (wt_name != target_name or change.is_reparented())):
-                if target_path == '':
-                    parent_trans = ROOT_PARENT
-                else:
-                    parent_trans = tt.trans_id_file_id(target_parent)
-                if wt_path == '' and wt_versioned:
-                    tt.adjust_root_path(target_name, parent_trans)
-                else:
-                    tt.adjust_path(target_name, parent_trans, trans_id)
-            if wt_executable != target_executable and target_kind == "file":
-                tt.set_executability(target_executable, trans_id)
-        if working_tree.supports_content_filtering():
-            for (trans_id, mode_id, target_path), bytes in (
-                    target_tree.iter_files_bytes(deferred_files)):
-                # We're reverting a tree to the target tree so using the
-                # target tree to find the file path seems the best choice
-                # here IMO - Ian C 27/Oct/2009
-                filters = working_tree._content_filter_stack(target_path)
-                bytes = filtered_output_bytes(
-                    bytes, filters,
-                    ContentFilterContext(target_path, working_tree))
-                tt.create_file(bytes, trans_id, mode_id)
-        else:
-            for (trans_id, mode_id, target_path), bytes in target_tree.iter_files_bytes(
-                    deferred_files):
-                tt.create_file(bytes, trans_id, mode_id)
-        tt.fixup_new_roots()
-    finally:
-        if basis_tree is not None:
-            basis_tree.unlock()
+                    parent_trans_id = tt.trans_id_tree_path(osutils.dirname(wt_path))
+                    backup_name = tt._available_backup_name(
+                        wt_name, parent_trans_id)
+                    tt.adjust_path(backup_name, parent_trans_id, trans_id)
+                    new_trans_id = tt.create_path(wt_name, parent_trans_id)
+                    if wt_versioned and target_versioned:
+                        tt.unversion_file(trans_id)
+                        tt.version_file(
+                            new_trans_id, file_id=getattr(change, 'file_id', None))
+                    # New contents should have the same unix perms as old
+                    # contents
+                    mode_id = trans_id
+                    trans_id = new_trans_id
+            if target_kind in ('directory', 'tree-reference'):
+                tt.create_directory(trans_id)
+                if target_kind == 'tree-reference':
+                    revision = target_tree.get_reference_revision(
+                        target_path)
+                    tt.set_tree_reference(revision, trans_id)
+            elif target_kind == 'symlink':
+                tt.create_symlink(target_tree.get_symlink_target(
+                    target_path), trans_id)
+            elif target_kind == 'file':
+                deferred_files.append(
+                    (target_path, (trans_id, mode_id, target_path)))
+                if basis_tree is None:
+                    basis_tree = working_tree.basis_tree()
+                    es.enter_context(basis_tree.lock_read())
+                new_sha1 = target_tree.get_file_sha1(target_path)
+                basis_inter = InterTree.get(basis_tree, target_tree)
+                basis_path = basis_inter.find_source_path(target_path)
+                if (basis_path is not None and
+                        new_sha1 == basis_tree.get_file_sha1(basis_path)):
+                    # If the new contents of the file match what is in basis,
+                    # then there is no need to store in merge_modified.
+                    if basis_path in merge_modified:
+                        del merge_modified[basis_path]
+                else:
+                    merge_modified[target_path] = new_sha1
+
+                # preserve the execute bit when backing up
+                if keep_content and wt_executable == target_executable:
+                    tt.set_executability(target_executable, trans_id)
+            elif target_kind is not None:
+                raise AssertionError(target_kind)
+        if not wt_versioned and target_versioned:
+            tt.version_file(
+                trans_id, file_id=getattr(change, 'file_id', None))
+        if wt_versioned and not target_versioned:
+            tt.unversion_file(trans_id)
+        if (target_name is not None
+                and (wt_name != target_name or change.is_reparented())):
+            if target_path == '':
+                parent_trans = ROOT_PARENT
+            else:
+                parent_trans = tt.trans_id_file_id(target_parent)
+            if wt_path == '' and wt_versioned:
+                tt.adjust_root_path(target_name, parent_trans)
+            else:
+                tt.adjust_path(target_name, parent_trans, trans_id)
+        if wt_executable != target_executable and target_kind == "file":
+            tt.set_executability(target_executable, trans_id)
+    if working_tree.supports_content_filtering():
+        for (trans_id, mode_id, target_path), bytes in (
+                target_tree.iter_files_bytes(deferred_files)):
+            # We're reverting a tree to the target tree so using the
+            # target tree to find the file path seems the best choice
+            # here IMO - Ian C 27/Oct/2009
+            filters = working_tree._content_filter_stack(target_path)
+            bytes = filtered_output_bytes(
+                bytes, filters,
+                ContentFilterContext(target_path, working_tree))
+            tt.create_file(bytes, trans_id, mode_id)
+    else:
+        for (trans_id, mode_id, target_path), bytes in target_tree.iter_files_bytes(
+                deferred_files):
+            tt.create_file(bytes, trans_id, mode_id)
+    tt.fixup_new_roots()
     return merge_modified
 
 
@@ -1162,9 +920,17 @@
         existing_file, new_file = trans_id, last_trans_id
     else:
         existing_file, new_file = last_trans_id, trans_id
-    new_name = tt.final_name(existing_file) + '.moved'
-    tt.adjust_path(new_name, final_parent, existing_file)
-    yield (c_type, 'Moved existing file to', existing_file, new_file)
+    if (not tt._tree.has_versioned_directories() and
+            tt.final_kind(trans_id) == 'directory' and
+            tt.final_kind(last_trans_id) == 'directory'):
+        _reparent_transform_children(tt, existing_file, new_file)
+        tt.delete_contents(existing_file)
+        tt.unversion_file(existing_file)
+        tt.cancel_creation(existing_file)
+    else:
+        new_name = tt.final_name(existing_file) + '.moved'
+        tt.adjust_path(new_name, final_parent, existing_file)
+        yield (c_type, 'Moved existing file to', existing_file, new_file)
 
 
 def resolve_parent_loop(tt, path_tree, c_type, cur):

=== modified file 'breezy/workingtree.py'
--- breezy/workingtree.py	2020-08-15 17:47:31 +0000
+++ breezy/workingtree.py	2020-09-02 17:42:36 +0000
@@ -1077,10 +1077,8 @@
         """
         raise NotImplementedError(self.unlock)
 
-    _marker = object()
-
     def update(self, change_reporter=None, possible_transports=None,
-               revision=None, old_tip=_marker, show_base=False):
+               revision=None, old_tip=None, show_base=False):
         """Update a working tree along its branch.
 
         This will update the branch if its bound too, which means we have
@@ -1112,105 +1110,7 @@
             returned (old tip of the branch or None). _marker is used
             otherwise.
         """
-        if self.branch.get_bound_location() is not None:
-            self.lock_write()
-            update_branch = (old_tip is self._marker)
-        else:
-            self.lock_tree_write()
-            update_branch = False
-        try:
-            if update_branch:
-                old_tip = self.branch.update(possible_transports)
-            else:
-                if old_tip is self._marker:
-                    old_tip = None
-            return self._update_tree(old_tip, change_reporter, revision, show_base)
-        finally:
-            self.unlock()
-
-    def _update_tree(self, old_tip=None, change_reporter=None, revision=None,
-                     show_base=False):
-        """Update a tree to the master branch.
-
-        :param old_tip: if supplied, the previous tip revision the branch,
-            before it was changed to the master branch's tip.
-        """
-        # here if old_tip is not None, it is the old tip of the branch before
-        # it was updated from the master branch. This should become a pending
-        # merge in the working tree to preserve the user existing work.  we
-        # cant set that until we update the working trees last revision to be
-        # one from the new branch, because it will just get absorbed by the
-        # parent de-duplication logic.
-        #
-        # We MUST save it even if an error occurs, because otherwise the users
-        # local work is unreferenced and will appear to have been lost.
-        #
-        with self.lock_tree_write():
-            nb_conflicts = 0
-            try:
-                last_rev = self.get_parent_ids()[0]
-            except IndexError:
-                last_rev = _mod_revision.NULL_REVISION
-            if revision is None:
-                revision = self.branch.last_revision()
-
-            old_tip = old_tip or _mod_revision.NULL_REVISION
-
-            if not _mod_revision.is_null(old_tip) and old_tip != last_rev:
-                # the branch we are bound to was updated
-                # merge those changes in first
-                base_tree = self.basis_tree()
-                other_tree = self.branch.repository.revision_tree(old_tip)
-                nb_conflicts = merge.merge_inner(self.branch, other_tree,
-                                                 base_tree, this_tree=self,
-                                                 change_reporter=change_reporter,
-                                                 show_base=show_base)
-                if nb_conflicts:
-                    self.add_parent_tree((old_tip, other_tree))
-                    note(gettext('Rerun update after fixing the conflicts.'))
-                    return nb_conflicts
-
-            if last_rev != _mod_revision.ensure_null(revision):
-                # the working tree is up to date with the branch
-                # we can merge the specified revision from master
-                to_tree = self.branch.repository.revision_tree(revision)
-                to_root_id = to_tree.path2id('')
-
-                basis = self.basis_tree()
-                with basis.lock_read():
-                    if (basis.path2id('') is None or basis.path2id('') != to_root_id):
-                        self.set_root_id(to_root_id)
-                        self.flush()
-
-                # determine the branch point
-                graph = self.branch.repository.get_graph()
-                base_rev_id = graph.find_unique_lca(self.branch.last_revision(),
-                                                    last_rev)
-                base_tree = self.branch.repository.revision_tree(base_rev_id)
-
-                nb_conflicts = merge.merge_inner(self.branch, to_tree, base_tree,
-                                                 this_tree=self,
-                                                 change_reporter=change_reporter,
-                                                 show_base=show_base)
-                self.set_last_revision(revision)
-                # TODO - dedup parents list with things merged by pull ?
-                # reuse the tree we've updated to to set the basis:
-                parent_trees = [(revision, to_tree)]
-                merges = self.get_parent_ids()[1:]
-                # Ideally we ask the tree for the trees here, that way the working
-                # tree can decide whether to give us the entire tree or give us a
-                # lazy initialised tree. dirstate for instance will have the trees
-                # in ram already, whereas a last-revision + basis-inventory tree
-                # will not, but also does not need them when setting parents.
-                for parent in merges:
-                    parent_trees.append(
-                        (parent, self.branch.repository.revision_tree(parent)))
-                if not _mod_revision.is_null(old_tip):
-                    parent_trees.append(
-                        (old_tip, self.branch.repository.revision_tree(old_tip)))
-                self.set_parent_trees(parent_trees)
-                last_rev = parent_trees[0][0]
-            return nb_conflicts
+        raise NotImplementedError(self.update)
 
     def set_conflicts(self, arg):
         raise errors.UnsupportedOperation(self.set_conflicts, self)