Merge lp:~jelmer/brz/transform into lp:brz/3.1

[Jelmer Vernooij]

Update the GitTreeTransform to not use file ids internally.

Update the GitTreeTransform to not use file ids internally.

Git file ids are tied to the path, which can lead to all sorts of odd behaviour.

[Jelmer Vernooij (jelmer)]

review: Approve

=== modified file 'breezy/bzr/transform.py'
--- breezy/bzr/transform.py	2020-08-15 14:57:23 +0000
+++ breezy/bzr/transform.py	2020-08-20 19:27:58 +0000
@@ -1913,6 +1913,9 @@
         self._iter_changes_cache = {
             c.file_id: c for c in self._transform.iter_changes()}
 
+    def supports_setting_file_ids(self):
+        return True
+
     def supports_tree_reference(self):
         # TODO(jelmer): Support tree references in PreviewTree.
         # return self._transform._tree.supports_tree_reference()
@@ -2169,21 +2172,28 @@
         file_id = self.path2id(path)
         changes = self._iter_changes_cache.get(file_id)
         if changes is None:
-            get_old = True
+            if file_id is None:
+                old_path = None
+            else:
+                old_path = self._transform._tree.id2path(file_id)
         else:
-            changed_content, versioned, kind = (
-                changes.changed_content, changes.versioned, changes.kind)
-            if kind[1] is None:
+            if changes.kind[1] is None:
                 return None
-            get_old = (kind[0] == 'file' and versioned[0])
-        if get_old:
+            if changes.kind[0] == 'file' and changes.versioned[0]:
+                old_path = changes.path[0]
+            else:
+                old_path = None
+        if old_path is not None:
             old_annotation = self._transform._tree.annotate_iter(
-                path, default_revision=default_revision)
+                old_path, default_revision=default_revision)
         else:
             old_annotation = []
         if changes is None:
-            return old_annotation
-        if not changed_content:
+            if old_path is None:
+                return None
+            else:
+                return old_annotation
+        if not changes.changed_content:
             return old_annotation
         # TODO: This is doing something similar to what WT.annotate_iter is
         #       doing, however it fails slightly because it doesn't know what
@@ -2193,7 +2203,7 @@
         #       It would be nice to be able to use the new Annotator based
         #       approach, as well.
         return annotate.reannotate([old_annotation],
-                                   self.get_file(path).readlines(),
+                                   self.get_file_lines(path),
                                    default_revision)
 
     def walkdirs(self, prefix=''):
@@ -2215,7 +2225,7 @@
                 else:
                     kind = 'unknown'
                     versioned_kind = self._transform._tree.stored_kind(
-                        self._transform._tree.id2path(file_id))
+                        path_from_root)
                 if versioned_kind == 'directory':
                     subdirs.append(child_id)
                 children.append((path_from_root, basename, kind, None,

=== modified file 'breezy/git/commit.py'
--- breezy/git/commit.py	2020-08-14 19:54:16 +0000
+++ breezy/git/commit.py	2020-08-20 19:27:58 +0000
@@ -80,6 +80,9 @@
     def record_iter_changes(self, workingtree, basis_revid, iter_changes):
         seen_root = False
         for change in iter_changes:
+            if change.kind == (None, None):
+                # Ephemeral
+                continue
             if change.versioned[0] and not change.copied:
                 file_id = self._mapping.generate_file_id(change.path[0])
             elif change.versioned[1]:

=== modified file 'breezy/git/transform.py'
--- breezy/git/transform.py	2020-08-14 19:53:25 +0000
+++ breezy/git/transform.py	2020-08-20 19:27:58 +0000
@@ -19,14 +19,30 @@
 
 import errno
 import os
-from stat import S_ISREG
+import posixpath
+from stat import S_IEXEC, S_ISREG
 import time
 
-from .. import conflicts, errors, multiparent, osutils, trace, ui, urlutils
+from .mapping import encode_git_path, mode_kind, mode_is_executable, object_mode
+from .tree import GitTree, GitTreeDirectory, GitTreeSymlink, GitTreeFile
+
+from .. import (
+    annotate,
+    conflicts,
+    errors,
+    multiparent,
+    osutils,
+    revision as _mod_revision,
+    trace,
+    ui,
+    urlutils,
+    )
 from ..i18n import gettext
 from ..mutabletree import MutableTree
-from ..sixish import viewitems, viewvalues
+from ..tree import InterTree, TreeChange
+from ..sixish import text_type, viewitems, viewvalues
 from ..transform import (
+    PreviewTree,
     TreeTransform,
     _TransformResults,
     _FileMover,
@@ -39,10 +55,9 @@
     ReusingTransform,
     MalformedTransform,
     )
-from ..bzr.inventorytree import InventoryTreeChange
 
-from ..bzr import inventory
-from ..bzr.transform import TransformPreview as GitTransformPreview
+from dulwich.index import commit_tree, blob_from_path_and_stat
+from dulwich.objects import Blob
 
 
 class TreeTransformBase(TreeTransform):
@@ -60,19 +75,17 @@
         super(TreeTransformBase, self).__init__(tree, pb=pb)
         # mapping of trans_id => (sha1 of content, stat_value)
         self._observed_sha1s = {}
-        # Mapping of trans_id -> new file_id
-        self._new_id = {}
-        # Mapping of old file-id -> trans_id
-        self._non_present_ids = {}
-        # Mapping of new file_id -> trans_id
-        self._r_new_id = {}
+        # Set of versioned trans ids
+        self._versioned = set()
         # The trans_id that will be used as the tree root
-        if tree.is_versioned(''):
-            self._new_root = self.trans_id_tree_path('')
-        else:
-            self._new_root = None
+        self.root = self.trans_id_tree_path('')
         # Whether the target is case sensitive
         self._case_sensitive_target = case_sensitive
+        self._symlink_target = {}
+
+    @property
+    def mapping(self):
+        return self._tree.mapping
 
     def finalize(self):
         """Release the working tree lock, if held.
@@ -87,11 +100,6 @@
         self._tree.unlock()
         self._tree = None
 
-    def __get_root(self):
-        return self._new_root
-
-    root = property(__get_root)
-
     def create_path(self, name, parent):
         """Assign a transaction id to a new path"""
         trans_id = self.assign_id()
@@ -101,35 +109,7 @@
 
     def adjust_root_path(self, name, parent):
         """Emulate moving the root by moving all children, instead.
-
-        We do this by undoing the association of root's transaction id with the
-        current tree.  This allows us to create a new directory with that
-        transaction id.  We unversion the root directory and version the
-        physically new directory, and hope someone versions the tree root
-        later.
         """
-        old_root = self._new_root
-        old_root_file_id = self.final_file_id(old_root)
-        # force moving all children of root
-        for child_id in self.iter_tree_children(old_root):
-            if child_id != parent:
-                self.adjust_path(self.final_name(child_id),
-                                 self.final_parent(child_id), child_id)
-            file_id = self.final_file_id(child_id)
-            if file_id is not None:
-                self.unversion_file(child_id)
-            self.version_file(child_id, file_id=file_id)
-
-        # the physical root needs a new transaction id
-        self._tree_path_ids.pop("")
-        self._tree_id_paths.pop(old_root)
-        self._new_root = self.trans_id_tree_path('')
-        if parent == old_root:
-            parent = self._new_root
-        self.adjust_path(name, parent, old_root)
-        self.create_directory(old_root)
-        self.version_file(old_root, file_id=old_root_file_id)
-        self.unversion_file(self._new_root)
 
     def fixup_new_roots(self):
         """Reinterpret requests to change the root directory
@@ -149,26 +129,12 @@
             return
         if len(new_roots) != 1:
             raise ValueError('A tree cannot have two roots!')
-        if self._new_root is None:
-            self._new_root = new_roots[0]
-            return
         old_new_root = new_roots[0]
         # unversion the new root's directory.
-        if self.final_kind(self._new_root) is None:
-            file_id = self.final_file_id(old_new_root)
-        else:
-            file_id = self.final_file_id(self._new_root)
-        if old_new_root in self._new_id:
+        if old_new_root in self._versioned:
             self.cancel_versioning(old_new_root)
         else:
             self.unversion_file(old_new_root)
-        # if, at this stage, root still has an old file_id, zap it so we can
-        # stick a new one in.
-        if (self.tree_file_id(self._new_root) is not None
-                and self._new_root not in self._removed_id):
-            self.unversion_file(self._new_root)
-        if file_id is not None:
-            self.version_file(self._new_root, file_id=file_id)
 
         # Now move children of new root into old root directory.
         # Ensure all children are registered with the transaction, but don't
@@ -176,7 +142,7 @@
         list(self.iter_tree_children(old_new_root))
         # Move all children of new root into old root directory.
         for child in self.by_parent().get(old_new_root, []):
-            self.adjust_path(self.final_name(child), self._new_root, child)
+            self.adjust_path(self.final_name(child), self.root, child)
 
         # Ensure old_new_root has no directory.
         if old_new_root in self._new_contents:
@@ -185,8 +151,8 @@
             self.delete_contents(old_new_root)
 
         # prevent deletion of root directory.
-        if self._new_root in self._removed_contents:
-            self.cancel_deletion(self._new_root)
+        if self.root in self._removed_contents:
+            self.cancel_deletion(self.root)
 
         # destroy path info for old_new_root.
         del self._new_parent[old_new_root]
@@ -200,24 +166,14 @@
         """
         if file_id is None:
             raise ValueError('None is not a valid file id')
-        if file_id in self._r_new_id and self._r_new_id[file_id] is not None:
-            return self._r_new_id[file_id]
-        else:
-            try:
-                path = self._tree.id2path(file_id)
-            except errors.NoSuchId:
-                if file_id in self._non_present_ids:
-                    return self._non_present_ids[file_id]
-                else:
-                    trans_id = self.assign_id()
-                    self._non_present_ids[file_id] = trans_id
-                    return trans_id
-            else:
-                return self.trans_id_tree_path(path)
+        path = self.mapping.parse_file_id(file_id)
+        return self.trans_id_tree_path(path)
 
     def version_file(self, trans_id, file_id=None):
         """Schedule a file to become versioned."""
-        raise NotImplementedError(self.version_file)
+        if trans_id in self._versioned:
+            raise errors.DuplicateKey(key=trans_id)
+        self._versioned.add(trans_id)
 
     def cancel_versioning(self, trans_id):
         """Undo a previous versioning of a file"""
@@ -234,53 +190,25 @@
             stale_ids = self._needs_rename.difference(self._new_name)
             stale_ids.difference_update(self._new_parent)
             stale_ids.difference_update(self._new_contents)
-            stale_ids.difference_update(self._new_id)
+            stale_ids.difference_update(self._versioned)
             needs_rename = self._needs_rename.difference(stale_ids)
             id_sets = (needs_rename, self._new_executability)
         else:
             id_sets = (self._new_name, self._new_parent, self._new_contents,
-                       self._new_id, self._new_executability)
+                       self._versioned, self._new_executability)
         for id_set in id_sets:
             new_ids.update(id_set)
         return sorted(FinalPaths(self).get_paths(new_ids))
 
-    def tree_file_id(self, trans_id):
-        """Determine the file id associated with the trans_id in the tree"""
-        path = self.tree_path(trans_id)
-        if path is None:
-            return None
-        # the file is old; the old id is still valid
-        if self._new_root == trans_id:
-            return self._tree.path2id('')
-        return self._tree.path2id(path)
-
     def final_is_versioned(self, trans_id):
-        return self.final_file_id(trans_id) is not None
-
-    def final_file_id(self, trans_id):
-        """Determine the file id after any changes are applied, or None.
-
-        None indicates that the file will not be versioned after changes are
-        applied.
-        """
-        try:
-            return self._new_id[trans_id]
-        except KeyError:
-            if trans_id in self._removed_id:
-                return None
-        return self.tree_file_id(trans_id)
-
-    def inactive_file_id(self, trans_id):
-        """Return the inactive file_id associated with a transaction id.
-        That is, the one in the tree or in non_present_ids.
-        The file_id may actually be active, too.
-        """
-        file_id = self.tree_file_id(trans_id)
-        if file_id is not None:
-            return file_id
-        for key, value in viewitems(self._non_present_ids):
-            if value == trans_id:
-                return key
+        if trans_id in self._versioned:
+            return True
+        if trans_id in self._removed_id:
+            return False
+        orig_path = self.tree_path(trans_id)
+        if orig_path is None:
+            return False
+        return self._tree.is_versioned(orig_path)
 
     def find_raw_conflicts(self):
         """Find any violations of inventory or filesystem invariants"""
@@ -316,8 +244,11 @@
         for trans_id in self._removed_id:
             path = self.tree_path(trans_id)
             if path is not None:
-                if self._tree.stored_kind(path) == 'directory':
-                    parents.append(trans_id)
+                try:
+                    if self._tree.stored_kind(path) == 'directory':
+                        parents.append(trans_id)
+                except errors.NoSuchFile:
+                    pass
             elif self.tree_kind(trans_id) == 'directory':
                 parents.append(trans_id)
 
@@ -392,7 +323,7 @@
         However, existing entries with no contents are okay.
         """
         conflicts = []
-        for trans_id in self._new_id:
+        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
@@ -598,7 +529,7 @@
     def _affected_ids(self):
         """Return the set of transform ids affected by the transform"""
         trans_ids = set(self._removed_id)
-        trans_ids.update(self._new_id)
+        trans_ids.update(self._versioned)
         trans_ids.update(self._removed_contents)
         trans_ids.update(self._new_contents)
         trans_ids.update(self._new_executability)
@@ -606,130 +537,78 @@
         trans_ids.update(self._new_parent)
         return trans_ids
 
-    def _get_file_id_maps(self):
-        """Return mapping of file_ids to trans_ids in the to and from states"""
-        trans_ids = self._affected_ids()
-        from_trans_ids = {}
-        to_trans_ids = {}
-        # Build up two dicts: trans_ids associated with file ids in the
-        # FROM state, vs the TO state.
-        for trans_id in trans_ids:
-            from_file_id = self.tree_file_id(trans_id)
-            if from_file_id is not None:
-                from_trans_ids[from_file_id] = trans_id
-            to_file_id = self.final_file_id(trans_id)
-            if to_file_id is not None:
-                to_trans_ids[to_file_id] = trans_id
-        return from_trans_ids, to_trans_ids
-
-    def _from_file_data(self, from_trans_id, from_versioned, from_path):
-        """Get data about a file in the from (tree) state
-
-        Return a (name, parent, kind, executable) tuple
-        """
-        from_path = self._tree_id_paths.get(from_trans_id)
-        if from_versioned:
-            # get data from working tree if versioned
-            from_entry = next(self._tree.iter_entries_by_dir(
-                specific_files=[from_path]))[1]
-            from_name = from_entry.name
-            from_parent = from_entry.parent_id
-        else:
-            from_entry = None
-            if from_path is None:
-                # File does not exist in FROM state
-                from_name = None
-                from_parent = None
-            else:
-                # File exists, but is not versioned.  Have to use path-
-                # splitting stuff
-                from_name = os.path.basename(from_path)
-                tree_parent = self.get_tree_parent(from_trans_id)
-                from_parent = self.tree_file_id(tree_parent)
-        if from_path is not None:
-            from_kind, from_executable, from_stats = \
-                self._tree._comparison_data(from_entry, from_path)
-        else:
-            from_kind = None
-            from_executable = False
-        return from_name, from_parent, from_kind, from_executable
-
-    def _to_file_data(self, to_trans_id, from_trans_id, from_executable):
-        """Get data about a file in the to (target) state
-
-        Return a (name, parent, kind, executable) tuple
-        """
-        to_name = self.final_name(to_trans_id)
-        to_kind = self.final_kind(to_trans_id)
-        to_parent = self.final_file_id(self.final_parent(to_trans_id))
-        if to_trans_id in self._new_executability:
-            to_executable = self._new_executability[to_trans_id]
-        elif to_trans_id == from_trans_id:
-            to_executable = from_executable
-        else:
-            to_executable = False
-        return to_name, to_parent, to_kind, to_executable
-
-    def iter_changes(self):
+    def iter_changes(self, want_unversioned=False):
         """Produce output in the same format as Tree.iter_changes.
 
         Will produce nonsensical results if invoked while inventory/filesystem
         conflicts (as reported by TreeTransform.find_raw_conflicts()) are present.
-
-        This reads the Transform, but only reproduces changes involving a
-        file_id.  Files that are not versioned in either of the FROM or TO
-        states are not reflected.
         """
         final_paths = FinalPaths(self)
-        from_trans_ids, to_trans_ids = self._get_file_id_maps()
+        trans_ids = self._affected_ids()
         results = []
-        # Now iterate through all active file_ids
-        for file_id in set(from_trans_ids).union(to_trans_ids):
+        # Now iterate through all active paths
+        for trans_id in trans_ids:
+            from_path = self.tree_path(trans_id)
             modified = False
-            from_trans_id = from_trans_ids.get(file_id)
             # find file ids, and determine versioning state
-            if from_trans_id is None:
+            if from_path is None:
                 from_versioned = False
-                from_trans_id = to_trans_ids[file_id]
             else:
-                from_versioned = True
-            to_trans_id = to_trans_ids.get(file_id)
-            if to_trans_id is None:
+                from_versioned = self._tree.is_versioned(from_path)
+            if not want_unversioned and not from_versioned:
+                from_path = None
+            to_path = final_paths.get_path(trans_id)
+            if to_path is None:
                 to_versioned = False
-                to_trans_id = from_trans_id
-            else:
-                to_versioned = True
-
-            if not from_versioned:
-                from_path = None
-            else:
-                from_path = self._tree_id_paths.get(from_trans_id)
-            if not to_versioned:
+            else:
+                to_versioned = self.final_is_versioned(trans_id)
+            if not want_unversioned and not to_versioned:
                 to_path = None
-            else:
-                to_path = final_paths.get_path(to_trans_id)
-
-            from_name, from_parent, from_kind, from_executable = \
-                self._from_file_data(from_trans_id, from_versioned, from_path)
-
-            to_name, to_parent, to_kind, to_executable = \
-                self._to_file_data(to_trans_id, from_trans_id, from_executable)
-
-            if from_kind != to_kind:
+
+            if from_versioned:
+                # get data from working tree if versioned
+                from_entry = next(self._tree.iter_entries_by_dir(
+                    specific_files=[from_path]))[1]
+                from_name = from_entry.name
+            else:
+                from_entry = None
+                if from_path is None:
+                    # File does not exist in FROM state
+                    from_name = None
+                else:
+                    # File exists, but is not versioned.  Have to use path-
+                    # splitting stuff
+                    from_name = os.path.basename(from_path)
+            if from_path is not None:
+                from_kind, from_executable, from_stats = \
+                    self._tree._comparison_data(from_entry, from_path)
+            else:
+                from_kind = None
+                from_executable = False
+
+            to_name = self.final_name(trans_id)
+            to_kind = self.final_kind(trans_id)
+            if trans_id in self._new_executability:
+                to_executable = self._new_executability[trans_id]
+            else:
+                to_executable = from_executable
+
+            if from_versioned and from_kind != to_kind:
                 modified = True
             elif to_kind in ('file', 'symlink') and (
-                    to_trans_id != from_trans_id
-                    or to_trans_id in self._new_contents):
+                    trans_id in self._new_contents):
                 modified = True
             if (not modified and from_versioned == to_versioned
-                and from_parent == to_parent and from_name == to_name
+                and from_path == to_path
+                and from_name == to_name
                     and from_executable == to_executable):
                 continue
+            if (from_path, to_path) == (None, None):
+                continue
             results.append(
-                InventoryTreeChange(
-                    file_id, (from_path, to_path), modified,
+                TreeChange(
+                    (from_path, to_path), modified,
                     (from_versioned, to_versioned),
-                    (from_parent, to_parent),
                     (from_name, to_name),
                     (from_kind, to_kind),
                     (from_executable, to_executable)))
@@ -744,7 +623,7 @@
         The tree is a snapshot, and altering the TreeTransform will invalidate
         it.
         """
-        raise NotImplementedError(self.get_preview_tree)
+        return GitPreviewTree(self)
 
     def commit(self, branch, message, merge_parents=None, strict=False,
                timestamp=None, timezone=None, committer=None, authors=None,
@@ -771,7 +650,7 @@
         """
         self._check_malformed()
         if strict:
-            unversioned = set(self._new_contents).difference(set(self._new_id))
+            unversioned = set(self._new_contents).difference(set(self._versioned))
             for trans_id in unversioned:
                 if not self.final_is_versioned(trans_id):
                     raise errors.StrictCommitFailed()
@@ -828,104 +707,6 @@
             return ()
         return (self._tree.get_file_lines(path),)
 
-    def serialize(self, serializer):
-        """Serialize this TreeTransform.
-
-        :param serializer: A Serialiser like pack.ContainerSerializer.
-        """
-        from .. import bencode
-        new_name = {k.encode('utf-8'): v.encode('utf-8')
-                    for k, v in viewitems(self._new_name)}
-        new_parent = {k.encode('utf-8'): v.encode('utf-8')
-                      for k, v in viewitems(self._new_parent)}
-        new_id = {k.encode('utf-8'): v
-                  for k, v in viewitems(self._new_id)}
-        new_executability = {k.encode('utf-8'): int(v)
-                             for k, v in viewitems(self._new_executability)}
-        tree_path_ids = {k.encode('utf-8'): v.encode('utf-8')
-                         for k, v in viewitems(self._tree_path_ids)}
-        non_present_ids = {k: v.encode('utf-8')
-                           for k, v in viewitems(self._non_present_ids)}
-        removed_contents = [trans_id.encode('utf-8')
-                            for trans_id in self._removed_contents]
-        removed_id = [trans_id.encode('utf-8')
-                      for trans_id in self._removed_id]
-        attribs = {
-            b'_id_number': self._id_number,
-            b'_new_name': new_name,
-            b'_new_parent': new_parent,
-            b'_new_executability': new_executability,
-            b'_new_id': new_id,
-            b'_tree_path_ids': tree_path_ids,
-            b'_removed_id': removed_id,
-            b'_removed_contents': removed_contents,
-            b'_non_present_ids': non_present_ids,
-            }
-        yield serializer.bytes_record(bencode.bencode(attribs),
-                                      ((b'attribs',),))
-        for trans_id, kind in sorted(viewitems(self._new_contents)):
-            if kind == 'file':
-                with open(self._limbo_name(trans_id), 'rb') as cur_file:
-                    lines = cur_file.readlines()
-                parents = self._get_parents_lines(trans_id)
-                mpdiff = multiparent.MultiParent.from_lines(lines, parents)
-                content = b''.join(mpdiff.to_patch())
-            if kind == 'directory':
-                content = b''
-            if kind == 'symlink':
-                content = self._read_symlink_target(trans_id)
-                if not isinstance(content, bytes):
-                    content = content.encode('utf-8')
-            yield serializer.bytes_record(
-                content, ((trans_id.encode('utf-8'), kind.encode('ascii')),))
-
-    def deserialize(self, records):
-        """Deserialize a stored TreeTransform.
-
-        :param records: An iterable of (names, content) tuples, as per
-            pack.ContainerPushParser.
-        """
-        from .. import bencode
-        names, content = next(records)
-        attribs = bencode.bdecode(content)
-        self._id_number = attribs[b'_id_number']
-        self._new_name = {k.decode('utf-8'): v.decode('utf-8')
-                          for k, v in viewitems(attribs[b'_new_name'])}
-        self._new_parent = {k.decode('utf-8'): v.decode('utf-8')
-                            for k, v in viewitems(attribs[b'_new_parent'])}
-        self._new_executability = {
-            k.decode('utf-8'): bool(v)
-            for k, v in viewitems(attribs[b'_new_executability'])}
-        self._new_id = {k.decode('utf-8'): v
-                        for k, v in viewitems(attribs[b'_new_id'])}
-        self._r_new_id = {v: k for k, v in viewitems(self._new_id)}
-        self._tree_path_ids = {}
-        self._tree_id_paths = {}
-        for bytepath, trans_id in viewitems(attribs[b'_tree_path_ids']):
-            path = bytepath.decode('utf-8')
-            trans_id = trans_id.decode('utf-8')
-            self._tree_path_ids[path] = trans_id
-            self._tree_id_paths[trans_id] = path
-        self._removed_id = {trans_id.decode('utf-8')
-                            for trans_id in attribs[b'_removed_id']}
-        self._removed_contents = set(
-            trans_id.decode('utf-8')
-            for trans_id in attribs[b'_removed_contents'])
-        self._non_present_ids = {
-            k: v.decode('utf-8')
-            for k, v in viewitems(attribs[b'_non_present_ids'])}
-        for ((trans_id, kind),), content in records:
-            trans_id = trans_id.decode('utf-8')
-            kind = kind.decode('ascii')
-            if kind == 'file':
-                mpdiff = multiparent.MultiParent.from_patch(content)
-                lines = mpdiff.to_lines(self._get_parents_texts(trans_id))
-                self.create_file(lines, trans_id)
-            if kind == 'directory':
-                self.create_directory(trans_id)
-            if kind == 'symlink':
-                self.create_symlink(content.decode('utf-8'), trans_id)
-
     def create_file(self, contents, trans_id, mode_id=None, sha1=None):
         """Schedule creation of a new file.
 
@@ -997,6 +778,14 @@
             elif c[0] == 'missing parent':
                 # TODO(jelmer): This should not make it to here
                 yield TextConflict(fp.get_path(c[2]))
+            elif c[0] == 'non-directory parent':
+                yield TextConflict(fp.get_path(c[2]))
+            elif c[0] == 'deleting parent':
+                # TODO(jelmer): This should not make it to here
+                yield TextConflict(fp.get_path(c[2]))
+            elif c[0] == 'parent loop':
+                # TODO(jelmer): This should not make it to here
+                yield TextConflict(fp.get_path(c[2]))
             else:
                 raise AssertionError('unknown conflict %s' % c[0])
 
@@ -1210,6 +999,7 @@
                 path = None
             trace.warning(
                 'Unable to create symlink "%s" on this filesystem.' % (path,))
+            self._symlink_target[trans_id] = target
         # We add symlink to _new_contents even if they are unsupported
         # and not created. These entries are subsequently used to avoid
         # conflicts on platforms that don't support symlink
@@ -1234,6 +1024,88 @@
         handle_orphan = conf.get('transform.orphan_policy')
         handle_orphan(self, trans_id, parent_id)
 
+    def final_entry(self, trans_id):
+        is_versioned = self.final_is_versioned(trans_id)
+        fp = FinalPaths(self)
+        tree_path = fp.get_path(trans_id)
+        if trans_id in self._new_contents:
+            path = self._limbo_name(trans_id)
+            st = os.lstat(path)
+            kind = mode_kind(st.st_mode)
+            name = self.final_name(trans_id)
+            file_id = self._tree.mapping.generate_file_id(tree_path)
+            parent_id = self._tree.mapping.generate_file_id(os.path.dirname(tree_path))
+            if kind == 'directory':
+                return GitTreeDirectory(
+                    file_id, self.final_name(trans_id), parent_id=parent_id), is_versioned
+            executable = mode_is_executable(st.st_mode)
+            mode = object_mode(kind, executable)
+            blob = blob_from_path_and_stat(encode_git_path(path), st)
+            if kind == 'symlink':
+                return GitTreeSymlink(
+                    file_id, name, parent_id,
+                    decode_git_path(blob.data)), is_versioned
+            elif kind == 'file':
+                return GitTreeFile(
+                    file_id, name, executable=executable, parent_id=parent_id,
+                    git_sha1=blob.id, text_size=len(blob.data)), is_versioned
+            else:
+                raise AssertionError(kind)
+        elif trans_id in self._removed_contents:
+            return None, None
+        else:
+            orig_path = self.tree_path(trans_id)
+            if orig_path is None:
+                return None, None
+            file_id = self._tree.mapping.generate_file_id(tree_path)
+            if tree_path == '':
+                parent_id = None
+            else:
+                parent_id = self._tree.mapping.generate_file_id(os.path.dirname(tree_path))
+            try:
+                ie = next(self._tree.iter_entries_by_dir(
+                    specific_files=[orig_path]))[1]
+                ie.file_id = file_id
+                ie.parent_id = parent_id
+                return ie, is_versioned
+            except StopIteration:
+                try:
+                    if self.tree_kind(trans_id) == 'directory':
+                        return GitTreeDirectory(
+                            file_id, self.final_name(trans_id), parent_id=parent_id), is_versioned
+                except OSError as e:
+                    if e.errno != errno.ENOTDIR:
+                        raise
+                return None, None
+
+    def final_git_entry(self, trans_id):
+        if trans_id in self._new_contents:
+            path = self._limbo_name(trans_id)
+            st = os.lstat(path)
+            kind = mode_kind(st.st_mode)
+            if kind == 'directory':
+                return None, None
+            executable = mode_is_executable(st.st_mode)
+            mode = object_mode(kind, executable)
+            blob = blob_from_path_and_stat(encode_git_path(path), st)
+        elif trans_id in self._removed_contents:
+            return None, None
+        else:
+            orig_path = self.tree_path(trans_id)
+            kind = self._tree.kind(orig_path)
+            executable = self._tree.is_executable(orig_path)
+            mode = object_mode(kind, executable)
+            if kind == 'symlink':
+                contents = self._tree.get_symlink_target(orig_path)
+            elif kind == 'file':
+                contents = self._tree.get_file_text(orig_path)
+            elif kind == 'directory':
+                return None, None
+            else:
+                raise AssertionError(kind)
+            blob = Blob.from_string(contents)
+        return blob, mode
+
 
 class GitTreeTransform(DiskTreeTransform):
     """Represent a tree transformation.
@@ -1454,20 +1326,11 @@
         self._limbo_children_names[parent][filename] = trans_id
         return limbo_name
 
-    def version_file(self, trans_id, file_id=None):
-        """Schedule a file to become versioned."""
-        if file_id is None:
-            raise ValueError()
-        unique_add(self._new_id, trans_id, file_id)
-        unique_add(self._r_new_id, file_id, trans_id)
-
     def cancel_versioning(self, trans_id):
         """Undo a previous versioning of a file"""
-        file_id = self._new_id[trans_id]
-        del self._new_id[trans_id]
-        del self._r_new_id[file_id]
+        self._versioned.remove(trans_id)
 
-    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
@@ -1477,8 +1340,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
         """
         for hook in MutableTree.hooks['pre_transform']:
@@ -1487,14 +1348,9 @@
             self._check_malformed()
         self.rename_count = 0
         with ui.ui_factory.nested_progress_bar() as child_pb:
-            if precomputed_delta is None:
-                child_pb.update(gettext('Apply phase'), 0, 2)
-                changes = self._generate_transform_changes()
-                offset = 1
-            else:
-                changes = [
-                    (op, np, ie) for (op, np, fid, ie) in precomputed_delta]
-                offset = 0
+            child_pb.update(gettext('Apply phase'), 0, 2)
+            index_changes = self._generate_index_changes()
+            offset = 1
             if _mover is None:
                 mover = _FileMover()
             else:
@@ -1509,9 +1365,7 @@
                 raise
             else:
                 mover.apply_deletions()
-        if self.final_file_id(self.root) is None:
-            changes = [e for e in changes if e[0] != '']
-        self._tree._apply_transform_delta(changes)
+        self._tree._apply_index_changes(index_changes)
         self._done = True
         self.finalize()
         return _TransformResults(modified_paths, self.rename_count)
@@ -1594,97 +1448,354 @@
         self._new_contents.clear()
         return modified_paths
 
-    def _inventory_altered(self):
-        """Determine which trans_ids need new Inventory entries.
-
-        An new entry is needed when anything that would be reflected by an
-        inventory entry changes, including file name, file_id, parent file_id,
-        file kind, and the execute bit.
-
-        Some care is taken to return entries with real changes, not cases
-        where the value is deleted and then restored to its original value,
-        but some actually unchanged values may be returned.
-
-        :returns: A list of (path, trans_id) for all items requiring an
-            inventory change. Ordered by path.
-        """
+    def _generate_index_changes(self):
+        """Generate an inventory delta for the current transform."""
+        removed_id = set(self._removed_id)
+        removed_id.update(self._removed_contents)
+        changes = {}
         changed_ids = set()
-        # Find entries whose file_ids are new (or changed).
-        new_file_id = set(t for t in self._new_id
-                          if self._new_id[t] != self.tree_file_id(t))
-        for id_set in [self._new_name, self._new_parent, new_file_id,
+        for id_set in [self._new_name, self._new_parent,
                        self._new_executability]:
             changed_ids.update(id_set)
-        # removing implies a kind change
-        changed_kind = set(self._removed_contents)
+        for id_set in [self._new_name, self._new_parent]:
+            removed_id.update(id_set)
         # so does adding
-        changed_kind.intersection_update(self._new_contents)
+        changed_kind = set(self._new_contents)
         # Ignore entries that are already known to have changed.
         changed_kind.difference_update(changed_ids)
         #  to keep only the truly changed ones
         changed_kind = (t for t in changed_kind
                         if self.tree_kind(t) != self.final_kind(t))
-        # all kind changes will alter the inventory
         changed_ids.update(changed_kind)
-        # To find entries with changed parent_ids, find parents which existed,
-        # but changed file_id.
-        # Now add all their children to the set.
-        for parent_trans_id in new_file_id:
-            changed_ids.update(self.iter_tree_children(parent_trans_id))
-        return sorted(FinalPaths(self).get_paths(changed_ids))
-
-    def _generate_transform_changes(self):
-        """Generate an inventory delta for the current transform."""
-        changes = []
-        new_paths = self._inventory_altered()
-        total_entries = len(new_paths) + len(self._removed_id)
+        for t in changed_kind:
+            if self.final_kind(t) == 'directory':
+                removed_id.add(t)
+                changed_ids.remove(t)
+        new_paths = sorted(FinalPaths(self).get_paths(changed_ids))
+        total_entries = len(new_paths) + len(removed_id)
         with ui.ui_factory.nested_progress_bar() as child_pb:
-            for num, trans_id in enumerate(self._removed_id):
+            for num, trans_id in enumerate(removed_id):
                 if (num % 10) == 0:
                     child_pb.update(gettext('removing file'),
                                     num, total_entries)
-                if trans_id == self._new_root:
-                    file_id = self._tree.path2id('')
-                else:
-                    file_id = self.tree_file_id(trans_id)
-                # File-id isn't really being deleted, just moved
-                if file_id in self._r_new_id:
+                try:
+                    path = self._tree_id_paths[trans_id]
+                except KeyError:
                     continue
-                path = self._tree_id_paths[trans_id]
-                changes.append((path, None, None))
-            new_path_file_ids = dict((t, self.final_file_id(t)) for p, t in
-                                     new_paths)
+                changes[path] = (None, None, None, None)
             for num, (path, trans_id) in enumerate(new_paths):
                 if (num % 10) == 0:
                     child_pb.update(gettext('adding file'),
-                                    num + len(self._removed_id), total_entries)
-                file_id = new_path_file_ids[trans_id]
-                if file_id is None:
-                    continue
+                                    num + len(removed_id), total_entries)
+
                 kind = self.final_kind(trans_id)
                 if kind is None:
-                    kind = self._tree.stored_kind(self._tree.id2path(file_id))
-                parent_trans_id = self.final_parent(trans_id)
-                parent_file_id = new_path_file_ids.get(parent_trans_id)
-                if parent_file_id is None:
-                    parent_file_id = self.final_file_id(parent_trans_id)
-                if trans_id in self._new_reference_revision:
-                    new_entry = inventory.TreeReference(
-                        file_id,
-                        self._new_name[trans_id],
-                        self.final_file_id(self._new_parent[trans_id]),
-                        None, self._new_reference_revision[trans_id])
-                else:
-                    new_entry = inventory.make_entry(kind,
-                                                     self.final_name(trans_id),
-                                                     parent_file_id, file_id)
-                try:
-                    old_path = self._tree.id2path(new_entry.file_id)
-                except errors.NoSuchId:
-                    old_path = None
-                new_executability = self._new_executability.get(trans_id)
-                if new_executability is not None:
-                    new_entry.executable = new_executability
-                changes.append(
-                    (old_path, path, new_entry))
-        return changes
+                    continue
+                versioned = self.final_is_versioned(trans_id)
+                if not versioned:
+                    continue
+                executability = self._new_executability.get(trans_id)
+                reference_revision = self._new_reference_revision.get(trans_id)
+                symlink_target = self._symlink_target.get(trans_id)
+                changes[path] = (
+                    kind, executability, reference_revision, symlink_target)
+        return [(p, k, e, rr, st) for (p, (k, e, rr, st)) in changes.items()]
+
+
+class GitTransformPreview(GitTreeTransform):
+    """A TreeTransform for generating preview trees.
+
+    Unlike TreeTransform, this version works when the input tree is a
+    RevisionTree, rather than a WorkingTree.  As a result, it tends to ignore
+    unversioned files in the input tree.
+    """
+
+    def __init__(self, tree, pb=None, case_sensitive=True):
+        tree.lock_read()
+        limbodir = osutils.mkdtemp(prefix='bzr-limbo-')
+        DiskTreeTransform.__init__(self, tree, limbodir, pb, case_sensitive)
+
+    def canonical_path(self, path):
+        return path
+
+    def tree_kind(self, trans_id):
+        path = self.tree_path(trans_id)
+        if path is None:
+            return None
+        kind = self._tree.path_content_summary(path)[0]
+        if kind == 'missing':
+            kind = None
+        return kind
+
+    def _set_mode(self, trans_id, mode_id, typefunc):
+        """Set the mode of new file contents.
+        The mode_id is the existing file to get the mode from (often the same
+        as trans_id).  The operation is only performed if there's a mode match
+        according to typefunc.
+        """
+        # is it ok to ignore this?  probably
+        pass
+
+    def iter_tree_children(self, parent_id):
+        """Iterate through the entry's tree children, if any"""
+        try:
+            path = self._tree_id_paths[parent_id]
+        except KeyError:
+            return
+        try:
+            for child in self._tree.iter_child_entries(path):
+                childpath = joinpath(path, child.name)
+                yield self.trans_id_tree_path(childpath)
+        except errors.NoSuchFile:
+            return
+
+    def new_orphan(self, trans_id, parent_id):
+        raise NotImplementedError(self.new_orphan)
+
+
+class GitPreviewTree(PreviewTree, GitTree):
+    """Partial implementation of Tree to support show_diff_trees"""
+
+    def __init__(self, transform):
+        PreviewTree.__init__(self, transform)
+        self.store = transform._tree.store
+        self.mapping = transform._tree.mapping
+        self._final_paths = FinalPaths(transform)
+
+    def supports_setting_file_ids(self):
+        return False
+
+    def _supports_executable(self):
+        return self._transform._limbo_supports_executable()
+
+    def walkdirs(self, prefix=''):
+        pending = [self._transform.root]
+        while len(pending) > 0:
+            parent_id = pending.pop()
+            children = []
+            subdirs = []
+            prefix = prefix.rstrip('/')
+            parent_path = self._final_paths.get_path(parent_id)
+            for child_id in self._all_children(parent_id):
+                path_from_root = self._final_paths.get_path(child_id)
+                basename = self._transform.final_name(child_id)
+                kind = self._transform.final_kind(child_id)
+                if kind is not None:
+                    versioned_kind = kind
+                else:
+                    kind = 'unknown'
+                    versioned_kind = self._transform._tree.stored_kind(
+                        path_from_root)
+                if versioned_kind == 'directory':
+                    subdirs.append(child_id)
+                children.append((path_from_root, basename, kind, None,
+                                 versioned_kind))
+            children.sort()
+            if parent_path.startswith(prefix):
+                yield parent_path, children
+            pending.extend(sorted(subdirs, key=self._final_paths.get_path,
+                                  reverse=True))
+
+    def iter_changes(self, from_tree, include_unchanged=False,
+                     specific_files=None, pb=None, extra_trees=None,
+                     require_versioned=True, want_unversioned=False):
+        """See InterTree.iter_changes.
+
+        This has a fast path that is only used when the from_tree matches
+        the transform tree, and no fancy options are supplied.
+        """
+        return InterTree.get(from_tree, self).iter_changes(
+            include_unchanged=include_unchanged,
+            specific_files=specific_files,
+            pb=pb,
+            extra_trees=extra_trees,
+            require_versioned=require_versioned,
+            want_unversioned=want_unversioned)
+
+    def get_file(self, path):
+        """See Tree.get_file"""
+        trans_id = self._path2trans_id(path)
+        if trans_id is None:
+            raise errors.NoSuchFile(path)
+        if trans_id in self._transform._new_contents:
+            name = self._transform._limbo_name(trans_id)
+            return open(name, 'rb')
+        if trans_id in self._transform._removed_contents:
+            raise errors.NoSuchFile(path)
+        orig_path = self._transform.tree_path(trans_id)
+        return self._transform._tree.get_file(orig_path)
+
+    def get_symlink_target(self, path):
+        """See Tree.get_symlink_target"""
+        trans_id = self._path2trans_id(path)
+        if trans_id is None:
+            raise errors.NoSuchFile(path)
+        if trans_id not in self._transform._new_contents:
+            orig_path = self._transform.tree_path(trans_id)
+            return self._transform._tree.get_symlink_target(orig_path)
+        name = self._transform._limbo_name(trans_id)
+        return osutils.readlink(name)
+
+    def annotate_iter(self, path, default_revision=_mod_revision.CURRENT_REVISION):
+        trans_id = self._path2trans_id(path)
+        if trans_id is None:
+            return None
+        orig_path = self._transform.tree_path(trans_id)
+        if orig_path is not None:
+            old_annotation = self._transform._tree.annotate_iter(
+                orig_path, default_revision=default_revision)
+        else:
+            old_annotation = []
+        try:
+            lines = self.get_file_lines(path)
+        except errors.NoSuchFile:
+            return None
+        return annotate.reannotate([old_annotation], lines, default_revision)
+
+    def get_file_text(self, path):
+        """Return the byte content of a file.
+
+        :param path: The path of the file.
+
+        :returns: A single byte string for the whole file.
+        """
+        with self.get_file(path) as my_file:
+            return my_file.read()
+
+    def get_file_lines(self, path):
+        """Return the content of a file, as lines.
+
+        :param path: The path of the file.
+        """
+        return osutils.split_lines(self.get_file_text(path))
+
+    def extras(self):
+        possible_extras = set(self._transform.trans_id_tree_path(p) for p
+                              in self._transform._tree.extras())
+        possible_extras.update(self._transform._new_contents)
+        possible_extras.update(self._transform._removed_id)
+        for trans_id in possible_extras:
+            if not self._transform.final_is_versioned(trans_id):
+                yield self._final_paths._determine_path(trans_id)
+
+    def path_content_summary(self, path):
+        trans_id = self._path2trans_id(path)
+        tt = self._transform
+        tree_path = tt.tree_path(trans_id)
+        kind = tt._new_contents.get(trans_id)
+        if kind is None:
+            if tree_path is None or trans_id in tt._removed_contents:
+                return 'missing', None, None, None
+            summary = tt._tree.path_content_summary(tree_path)
+            kind, size, executable, link_or_sha1 = summary
+        else:
+            link_or_sha1 = None
+            limbo_name = tt._limbo_name(trans_id)
+            if trans_id in tt._new_reference_revision:
+                kind = 'tree-reference'
+            if kind == 'file':
+                statval = os.lstat(limbo_name)
+                size = statval.st_size
+                if not tt._limbo_supports_executable():
+                    executable = False
+                else:
+                    executable = statval.st_mode & S_IEXEC
+            else:
+                size = None
+                executable = None
+            if kind == 'symlink':
+                link_or_sha1 = os.readlink(limbo_name)
+                if not isinstance(link_or_sha1, text_type):
+                    link_or_sha1 = link_or_sha1.decode(osutils._fs_enc)
+        executable = tt._new_executability.get(trans_id, executable)
+        return kind, size, executable, link_or_sha1
+
+    def get_file_mtime(self, path):
+        """See Tree.get_file_mtime"""
+        trans_id = self._path2trans_id(path)
+        if trans_id is None:
+            raise errors.NoSuchFile(path)
+        if trans_id not in self._transform._new_contents:
+            return self._transform._tree.get_file_mtime(
+                self._transform.tree_path(trans_id))
+        name = self._transform._limbo_name(trans_id)
+        statval = os.lstat(name)
+        return statval.st_mtime
+
+    def is_versioned(self, path):
+        trans_id = self._path2trans_id(path)
+        if trans_id is None:
+            # It doesn't exist, so it's not versioned.
+            return False
+        if trans_id in self._transform._versioned:
+            return True
+        if trans_id in self._transform._removed_id:
+            return False
+        orig_path = self._transform.tree_path(trans_id)
+        return self._transform._tree.is_versioned(orig_path)
+
+    def iter_entries_by_dir(self, specific_files=None, recurse_nested=False):
+        if recurse_nested:
+            raise NotImplementedError(
+                'follow tree references not yet supported')
+
+        # This may not be a maximally efficient implementation, but it is
+        # reasonably straightforward.  An implementation that grafts the
+        # TreeTransform changes onto the tree's iter_entries_by_dir results
+        # might be more efficient, but requires tricky inferences about stack
+        # position.
+        for trans_id, path in self._list_files_by_dir():
+            entry, is_versioned = self._transform.final_entry(trans_id)
+            if entry is None:
+                continue
+            if not is_versioned and entry.kind != 'directory':
+                continue
+            if specific_files is not None and path not in specific_files:
+                continue
+            if entry is not None:
+                yield path, entry
+
+    def _list_files_by_dir(self):
+        todo = [ROOT_PARENT]
+        while len(todo) > 0:
+            parent = todo.pop()
+            children = list(self._all_children(parent))
+            paths = dict(zip(children, self._final_paths.get_paths(children)))
+            children.sort(key=paths.get)
+            todo.extend(reversed(children))
+            for trans_id in children:
+                yield trans_id, paths[trans_id][0]
+
+    def revision_tree(self, revision_id):
+        return self._transform._tree.revision_tree(revision_id)
+
+    def _stat_limbo_file(self, trans_id):
+        name = self._transform._limbo_name(trans_id)
+        return os.lstat(name)
+
+    def git_snapshot(self, want_unversioned=False):
+        extra = set()
+        os = []
+        for trans_id, path in self._list_files_by_dir():
+            if not self._transform.final_is_versioned(trans_id):
+                if not want_unversioned:
+                    continue
+                extra.add(path)
+            o, mode = self._transform.final_git_entry(trans_id)
+            if o is not None:
+                self.store.add_object(o)
+                os.append((encode_git_path(path), o.id, mode))
+        if not os:
+            return None, extra
+        return commit_tree(self.store, os), extra
+
+    def iter_child_entries(self, path):
+        trans_id = self._path2trans_id(path)
+        if trans_id is None:
+            raise errors.NoSuchFile(path)
+        for child_trans_id in self._all_children(trans_id):
+            entry, is_versioned = self._transform.final_entry(trans_id)
+            if not is_versioned:
+                continue
+            if entry is not None:
+                yield entry

=== modified file 'breezy/git/tree.py'
--- breezy/git/tree.py	2020-08-14 20:01:27 +0000
+++ breezy/git/tree.py	2020-08-20 19:27:58 +0000
@@ -278,6 +278,27 @@
         """
         raise NotImplementedError(self.snapshot)
 
+    def preview_transform(self, pb=None):
+        from .transform import GitTransformPreview
+        return GitTransformPreview(self, pb=pb)
+
+    def find_related_paths_across_trees(self, paths, trees=[],
+                                        require_versioned=True):
+        if paths is None:
+            return None
+        if require_versioned:
+            trees = [self] + (trees if trees is not None else [])
+            unversioned = set()
+            for p in paths:
+                for t in trees:
+                    if t.is_versioned(p):
+                        break
+                else:
+                    unversioned.add(p)
+            if unversioned:
+                raise errors.PathsNotVersionedError(unversioned)
+        return filter(self.is_versioned, paths)
+
     def _submodule_info(self):
         if self._submodules is None:
             try:
@@ -661,23 +682,6 @@
         else:
             return (kind, None, None, None)
 
-    def find_related_paths_across_trees(self, paths, trees=[],
-                                        require_versioned=True):
-        if paths is None:
-            return None
-        if require_versioned:
-            trees = [self] + (trees if trees is not None else [])
-            unversioned = set()
-            for p in paths:
-                for t in trees:
-                    if t.is_versioned(p):
-                        break
-                else:
-                    unversioned.add(p)
-            if unversioned:
-                raise errors.PathsNotVersionedError(unversioned)
-        return filter(self.is_versioned, paths)
-
     def _iter_tree_contents(self, include_trees=False):
         if self.tree is None:
             return iter([])
@@ -729,10 +733,6 @@
                         mode_kind(mode)))
             yield path_decoded, children
 
-    def preview_transform(self, pb=None):
-        from .transform import GitTransformPreview
-        return GitTransformPreview(self, pb=pb)
-
 
 def tree_delta_from_git_changes(changes, mappings,
                                 specific_files=None,
@@ -967,8 +967,13 @@
             fileid = mapping.generate_file_id(newpath_decoded)
         else:
             fileid = None
+        if oldkind == 'directory' and newkind == 'directory':
+            modified = False
+        else:
+            modified = (oldsha != newsha) or (oldmode != newmode)
         yield InventoryTreeChange(
-            fileid, (oldpath_decoded, newpath_decoded), (oldsha != newsha),
+            fileid, (oldpath_decoded, newpath_decoded),
+            modified,
             (oldversioned, newversioned),
             (oldparent, newparent), (oldname, newname),
             (oldkind, newkind), (oldexe, newexe),
@@ -1222,11 +1227,32 @@
         # TODO(jelmer): Keep track of dirty per index
         self._index_dirty = True
 
-    def _index_add_entry(self, path, kind, flags=0, reference_revision=None):
+    def _apply_index_changes(self, changes):
+        for (path, kind, executability, reference_revision,
+             symlink_target) in changes:
+            if kind is None or kind == 'directory':
+                (index, subpath) = self._lookup_index(
+                    encode_git_path(path))
+                try:
+                    self._index_del_entry(index, subpath)
+                except KeyError:
+                    pass
+                else:
+                    self._versioned_dirs = None
+            else:
+                self._index_add_entry(
+                    path, kind,
+                    reference_revision=reference_revision,
+                    symlink_target=symlink_target)
+        self.flush()
+
+    def _index_add_entry(
+            self, path, kind, flags=0, reference_revision=None,
+            symlink_target=None):
         if kind == "directory":
             # Git indexes don't contain directories
             return
-        if kind == "file":
+        elif kind == "file":
             blob = Blob()
             try:
                 file, stat_val = self.get_file_with_stat(path)
@@ -1251,7 +1277,9 @@
                 # old index
                 stat_val = os.stat_result(
                     (stat.S_IFLNK, 0, 0, 0, 0, 0, 0, 0, 0, 0))
-            blob.set_raw_string(encode_git_path(self.get_symlink_target(path)))
+            if symlink_target is None:
+                symlink_target = self.get_symlink_target(path)
+            blob.set_raw_string(encode_git_path(symlink_target))
             # Add object to the repository if it didn't exist yet
             if blob.id not in self.store:
                 self.store.add_object(blob)
@@ -1543,25 +1571,6 @@
             self._versioned_dirs = None
             self.flush()
 
-    def find_related_paths_across_trees(self, paths, trees=[],
-                                        require_versioned=True):
-        if paths is None:
-            return None
-
-        if require_versioned:
-            trees = [self] + (trees if trees is not None else [])
-            unversioned = set()
-            for p in paths:
-                for t in trees:
-                    if t.is_versioned(p):
-                        break
-                else:
-                    unversioned.add(p)
-            if unversioned:
-                raise errors.PathsNotVersionedError(unversioned)
-
-        return filter(self.is_versioned, paths)
-
     def path_content_summary(self, path):
         """See Tree.path_content_summary."""
         try:
@@ -1588,17 +1597,21 @@
             return (kind, None, None, None)
 
     def stored_kind(self, relpath):
+        if relpath == '':
+            return 'directory'
         (index, index_path) = self._lookup_index(encode_git_path(relpath))
         if index is None:
-            return kind
+            return None
         try:
             mode = index[index_path].mode
         except KeyError:
-            return kind
+            for p in index:
+                if osutils.is_inside(
+                        decode_git_path(index_path), decode_git_path(p)):
+                    return 'directory'
+            return None
         else:
-            if S_ISGITLINK(mode):
-                return 'tree-reference'
-            return 'directory'
+            return mode_kind(mode)
 
     def kind(self, relpath):
         kind = osutils.file_kind(self.abspath(relpath))
@@ -1616,10 +1629,6 @@
         from .transform import GitTreeTransform
         return GitTreeTransform(self, pb=pb)
 
-    def preview_transform(self, pb=None):
-        from .transform import GitTransformPreview
-        return GitTransformPreview(self, pb=pb)
-
     def has_changes(self, _from_tree=None):
         """Quickly check that the tree contains at least one commitable change.
 

=== modified file 'breezy/git/workingtree.py'
--- breezy/git/workingtree.py	2020-08-10 03:38:37 +0000
+++ breezy/git/workingtree.py	2020-08-20 19:27:58 +0000
@@ -176,6 +176,12 @@
     def describe(self):
         return 'Text conflict in %(path)s' % self.__dict__
 
+    def __str__(self):
+        return self.describe()
+
+    def __repr__(self):
+        return "%s(%r)" % (type(self).__name__, self.path)
+
 
 class GitWorkingTree(MutableGitIndexTree, workingtree.WorkingTree):
     """A Git working tree."""
@@ -975,7 +981,6 @@
                 self._set_conflicted(path, path in by_path)
 
     def _set_conflicted(self, path, conflicted):
-        trace.mutter('change conflict: %r -> %r', path, conflicted)
         value = self.index[path]
         self._index_dirty = True
         if conflicted:
@@ -1159,26 +1164,6 @@
     def store_uncommitted(self):
         raise errors.StoringUncommittedNotSupported(self)
 
-    def _apply_transform_delta(self, changes):
-        for (old_path, new_path, ie) in changes:
-            if old_path is not None:
-                (index, old_subpath) = self._lookup_index(
-                    encode_git_path(old_path))
-                try:
-                    self._index_del_entry(index, old_subpath)
-                except KeyError:
-                    pass
-                else:
-                    self._versioned_dirs = None
-            if new_path is not None and ie.kind != 'directory':
-                if ie.kind == 'tree-reference':
-                    self._index_add_entry(
-                        new_path, ie.kind,
-                        reference_revision=ie.reference_revision)
-                else:
-                    self._index_add_entry(new_path, ie.kind)
-        self.flush()
-
     def annotate_iter(self, path,
                       default_revision=_mod_revision.CURRENT_REVISION):
         """See Tree.annotate_iter
@@ -1337,7 +1322,11 @@
     def get_reference_revision(self, path, branch=None):
         hexsha = self._read_submodule_head(path)
         if hexsha is None:
-            return _mod_revision.NULL_REVISION
+            (index, subpath) = self._lookup_index(
+                encode_git_path(path))
+            if subpath is None:
+                raise errors.NoSuchFile(path)
+            hexsha = index[subpath].sha
         return self.branch.lookup_foreign_revision_id(hexsha)
 
     def get_nested_tree(self, path):

=== modified file 'breezy/tests/per_tree/test_transform.py'
--- breezy/tests/per_tree/test_transform.py	2020-08-06 22:38:03 +0000
+++ breezy/tests/per_tree/test_transform.py	2020-08-20 19:27:58 +0000
@@ -30,8 +30,10 @@
     )
 from ...tree import (
     find_previous_path,
+    TreeChange,
     )
 
+from breezy.bzr.inventorytree import InventoryTreeChange
 
 from breezy.tests.per_tree import TestCaseWithTree
 
@@ -46,11 +48,6 @@
 
 class TestTransformPreview(TestCaseWithTree):
 
-    def setUp(self):
-        super(TestTransformPreview, self).setUp()
-        if not self.workingtree_format.supports_setting_file_ids:
-            self.skipTest('test not compatible with non-file-id trees yet')
-
     def create_tree(self):
         tree = self.make_branch_and_tree('.')
         self.build_tree_contents([('a', b'content 1')])
@@ -153,20 +150,39 @@
                            (False, False), False)],
                          list(preview_tree.iter_changes(revision_tree)))
 
+    def assertTreeChanges(self, expected, actual, tree):
+        # TODO(jelmer): Turn this into a matcher?
+        actual = list(actual)
+        if tree.supports_setting_file_ids():
+            self.assertEqual(expected, actual)
+        else:
+            expected = [
+                TreeChange(path=c.path, changed_content=c.changed_content,
+                           versioned=c.versioned, name=c.name,
+                           kind=c.kind, executable=c.executable,
+                           copied=c.copied) for c in expected]
+            actual = [
+                TreeChange(path=c.path, changed_content=c.changed_content,
+                           versioned=c.versioned, name=c.name,
+                           kind=c.kind, executable=c.executable,
+                           copied=c.copied) for c in actual]
+            self.assertEqual(expected, actual)
+
     def test_include_unchanged_succeeds(self):
         revision_tree, preview_tree = self.get_tree_and_preview_tree()
         changes = preview_tree.iter_changes(revision_tree,
                                             include_unchanged=True)
 
         root_id = revision_tree.path2id('')
-        root_entry = (root_id, ('', ''), False, (True, True), (None, None),
-                      ('', ''), ('directory', 'directory'), (False, False), False)
-        a_entry = (revision_tree.path2id('a'), ('a', 'a'), True, (True, True),
-                   (root_id, root_id), ('a', 'a'), ('file', 'file'),
-                   (False, False), False)
+        root_entry = InventoryTreeChange(
+            root_id, ('', ''), False, (True, True), (None, None),
+            ('', ''), ('directory', 'directory'), (False, False), False)
+        a_entry = InventoryTreeChange(
+            revision_tree.path2id('a'), ('a', 'a'), True, (True, True),
+            (root_id, root_id), ('a', 'a'), ('file', 'file'),
+            (False, False), False)
 
- 
-        self.assertEqual([root_entry, a_entry], list(changes))
+        self.assertTreeChanges([root_entry, a_entry], changes, preview_tree)
 
     def test_specific_files(self):
         revision_tree, preview_tree = self.get_tree_and_preview_tree()
@@ -177,7 +193,6 @@
                    (root_id, root_id), ('a', 'a'), ('file', 'file'),
                    (False, False), False)
 
- 
         self.assertEqual([a_entry], list(changes))
 
     def test_want_unversioned(self):
@@ -185,9 +200,10 @@
         changes = preview_tree.iter_changes(revision_tree,
                                             want_unversioned=True)
         root_id = revision_tree.path2id('')
-        a_entry = (revision_tree.path2id('a'), ('a', 'a'), True, (True, True),
-                   (root_id, root_id), ('a', 'a'), ('file', 'file'),
-                   (False, False), False)
+        a_entry = InventoryTreeChange(
+            revision_tree.path2id('a'), ('a', 'a'), True, (True, True),
+            (root_id, root_id), ('a', 'a'), ('file', 'file'),
+            (False, False), False)
 
         self.assertEqual([a_entry], list(changes))
 
@@ -304,7 +320,9 @@
         preview.new_file('new', preview.trans_id_tree_path('unchanged'),
                          [b'contents'], b'new-id')
         preview_tree = preview.get_preview_tree()
-        self.assertEqual(b'new-id', preview_tree.path2id('unchanged/new'))
+        self.assertTrue(preview_tree.is_versioned('unchanged/new'))
+        if self.workingtree_format.supports_setting_file_ids:
+            self.assertEqual(b'new-id', preview_tree.path2id('unchanged/new'))
 
     def test_path2id_moved(self):
         tree = self.make_branch_and_tree('tree')
@@ -339,7 +357,7 @@
         self.assertEqual(
             'new_name/child',
             find_previous_path(tree, preview_tree, 'old_name/child'))
-        if tree.supports_setting_file_ids:
+        if tree.supports_setting_file_ids():
             self.assertEqual(
                 tree.path2id('old_name/child'),
                 preview_tree.path2id('new_name/child'))
@@ -516,8 +534,11 @@
             (revid1, b'a\n'),
         ]
         annotation = preview_tree.annotate_iter(
+            'newname', default_revision=b'me:')
+        self.assertEqual(expected, annotation)
+        annotation = preview_tree.annotate_iter(
             'file', default_revision=b'me:')
-        self.assertEqual(expected, annotation)
+        self.assertIs(None, annotation)
 
     def test_annotate_deleted(self):
         tree = self.make_branch_and_tree('tree')
@@ -542,8 +563,8 @@
 
     def test_is_executable(self):
         preview = self.get_empty_preview()
-        preview.new_file('file', preview.root, [b'a\nb\nc\n'], b'file-id')
-        preview.set_executability(True, preview.trans_id_file_id(b'file-id'))
+        trans_id = preview.new_file('file', preview.root, [b'a\nb\nc\n'], b'file-id')
+        preview.set_executability(True, trans_id)
         preview_tree = preview.get_preview_tree()
         self.assertEqual(True, preview_tree.is_executable('file'))
 
@@ -568,6 +589,8 @@
         preview.create_file([b'b\nc\nd\ne\n'], trans_id)
         self.build_tree_contents([('wtb/file', b'a\nc\nd\nf\n')])
         tree_a = preview.get_preview_tree()
+        if not getattr(tree_a, 'plan_file_merge', None):
+            self.skipTest('tree does not support file merge planning')
         tree_a.set_parent_ids([base_id])
         self.addCleanup(tree_b.lock_read().unlock)
         self.assertEqual([
@@ -592,6 +615,8 @@
         preview.create_file([b'b\nc\nd\ne\n'], trans_id)
         self.build_tree_contents([('wtb/file', b'a\nc\nd\nf\n')])
         tree_a = preview.get_preview_tree()
+        if not getattr(tree_a, 'plan_file_merge', None):
+            self.skipTest('tree does not support file merge planning')
         tree_a.set_parent_ids([base_id])
         self.addCleanup(tree_b.lock_read().unlock)
         self.assertEqual([
@@ -624,6 +649,7 @@
         preview.new_file('new-versioned-file', preview.root, [b'contents'],
                          b'new-versioned-id')
         tree = preview.get_preview_tree()
+        self.assertEquals({'existing-file'}, set(work_tree.extras()))
         preview.unversion_file(preview.trans_id_tree_path('removed-file'))
         self.assertEqual({'new-file', 'removed-file', 'existing-file'},
                          set(tree.extras()))

=== modified file 'breezy/tests/per_workingtree/test_commit.py'
--- breezy/tests/per_workingtree/test_commit.py	2020-08-10 03:38:37 +0000
+++ breezy/tests/per_workingtree/test_commit.py	2020-08-20 19:27:58 +0000
@@ -169,7 +169,7 @@
         tree.lock_read()
         self.addCleanup(tree.unlock)
         changes = list(tree.iter_changes(tree.basis_tree()))
-        self.assertEqual(1, len(changes))
+        self.assertEqual(1, len(changes), changes)
         self.assertEqual((None, 'a/b'), changes[0].path)
 
     def test_commit_sets_last_revision(self):

=== modified file 'breezy/tests/per_workingtree/test_merge_from_branch.py'
--- breezy/tests/per_workingtree/test_merge_from_branch.py	2020-08-10 03:38:37 +0000
+++ breezy/tests/per_workingtree/test_merge_from_branch.py	2020-08-20 19:27:58 +0000
@@ -101,7 +101,7 @@
         tree_a.lock_read()
         self.addCleanup(tree_a.unlock)
         changes = list(tree_a.iter_changes(tree_a.basis_tree()))
-        self.assertEqual(1, len(changes))
+        self.assertEqual(1, len(changes), changes)
 
     def test_merge_type(self):
         this = self.make_branch_and_tree('this')

=== modified file 'breezy/tests/per_workingtree/test_smart_add.py'
--- breezy/tests/per_workingtree/test_smart_add.py	2018-11-21 03:20:30 +0000
+++ breezy/tests/per_workingtree/test_smart_add.py	2020-08-20 19:27:58 +0000
@@ -324,6 +324,9 @@
         self.build_tree_contents([('t1/file', b'content in t1')])
         t1.commit('Changing file in t1')
         t1.merge_from_branch(tb.branch)
+        fnames = ['file.%s' % s for s in ('BASE', 'THIS', 'OTHER')]
+        for fn in fnames:
+            self.assertPathExists(os.path.join(t1.basedir, fn))
         return t1
 
     def test_cant_add_generated_files_implicitly(self):

=== modified file 'breezy/tests/per_workingtree/test_transform.py'
--- breezy/tests/per_workingtree/test_transform.py	2020-08-15 03:35:17 +0000
+++ breezy/tests/per_workingtree/test_transform.py	2020-08-20 19:27:58 +0000
@@ -28,6 +28,7 @@
     transform,
     urlutils,
     )
+from ...tree import TreeChange
 from ...bzr.conflicts import (
     DeletingParent,
     DuplicateEntry,
@@ -72,6 +73,8 @@
     TransformRenameFailed,
 )
 
+from breezy.bzr.inventorytree import InventoryTreeChange
+
 from breezy.tests.per_workingtree import TestCaseWithWorkingTree
 
 
@@ -80,8 +83,6 @@
 
     def setUp(self):
         super(TestTreeTransform, self).setUp()
-        if not self.workingtree_format.supports_setting_file_ids:
-            self.skipTest('test not compatible with non-file-id trees yet')
         self.wt = self.make_branch_and_tree('wt')
 
     def transform(self):
@@ -180,6 +181,9 @@
 
     def test_apply_informs_tree_of_observed_sha1(self):
         trans, root, contents, sha1 = self.transform_for_sha1_test()
+        from ...bzr.workingtree import InventoryWorkingTree
+        if not isinstance(self.wt, InventoryWorkingTree):
+            self.skipTest('not a bzr working tree')
         trans_id = trans.new_file('file1', root, contents, file_id=b'file1-id',
                                   sha1=sha1)
         calls = []
@@ -330,7 +334,7 @@
         transform.new_directory('', ROOT_PARENT, None)
         transform.delete_contents(transform.root)
         transform.fixup_new_roots()
-        self.assertNotIn(transform.root, transform._new_id)
+        self.assertNotIn(transform.root, getattr(transform, '_new_id', []))
 
     def test_remove_root_fixup(self):
         transform, root = self.transform()
@@ -427,14 +431,16 @@
         if not tree.supports_tree_reference():
             raise tests.TestNotApplicable(
                 'Tree format does not support references')
+        nested_tree = self.make_branch_and_tree('nested')
+        nested_revid = nested_tree.commit('commit')
 
         trans_id = transform.new_directory('reference', root, b'subtree-id')
-        transform.set_tree_reference(b'subtree-revision', trans_id)
+        transform.set_tree_reference(nested_revid, trans_id)
         transform.apply()
         tree.lock_read()
         self.addCleanup(tree.unlock)
         self.assertEqual(
-            b'subtree-revision',
+            nested_revid,
             tree.get_reference_revision('reference'))
 
     def test_conflicts(self):
@@ -451,17 +457,29 @@
                          [('non-directory parent', trans_id)])
         tinman_id = transform.trans_id_tree_path('tinman')
         transform.adjust_path('name', tinman_id, trans_id2)
-        self.assertEqual(transform.find_raw_conflicts(),
-                         [('unversioned parent', tinman_id),
-                          ('missing parent', tinman_id)])
+        if self.wt.has_versioned_directories():
+            self.assertEqual(transform.find_raw_conflicts(),
+                             [('unversioned parent', tinman_id),
+                              ('missing parent', tinman_id)])
+        else:
+            self.assertEqual(transform.find_raw_conflicts(),
+                             [('missing parent', tinman_id)])
         lion_id = transform.create_path('lion', root)
-        self.assertEqual(transform.find_raw_conflicts(),
-                         [('unversioned parent', tinman_id),
-                          ('missing parent', tinman_id)])
+        if self.wt.has_versioned_directories():
+            self.assertEqual(transform.find_raw_conflicts(),
+                             [('unversioned parent', tinman_id),
+                              ('missing parent', tinman_id)])
+        else:
+            self.assertEqual(transform.find_raw_conflicts(),
+                             [('missing parent', tinman_id)])
         transform.adjust_path('name', lion_id, trans_id2)
-        self.assertEqual(transform.find_raw_conflicts(),
-                         [('unversioned parent', lion_id),
-                          ('missing parent', lion_id)])
+        if self.wt.has_versioned_directories():
+            self.assertEqual(transform.find_raw_conflicts(),
+                             [('unversioned parent', lion_id),
+                              ('missing parent', lion_id)])
+        else:
+            self.assertEqual(transform.find_raw_conflicts(),
+                             [('missing parent', lion_id)])
         transform.version_file(lion_id, file_id=b"Courage")
         self.assertEqual(transform.find_raw_conflicts(),
                          [('missing parent', lion_id),
@@ -496,11 +514,14 @@
         fp = FinalPaths(transform2)
         self.assertTrue('oz/tip' in transform2._tree_path_ids)
         self.assertEqual(fp.get_path(newtip), pathjoin('oz', 'tip'))
-        self.assertEqual(len(result), 2)
+        if self.wt.supports_setting_file_ids():
+            self.assertEqual(len(result), 2)
+            self.assertEqual((result[1][0], result[1][2]),
+                             ('duplicate id', newtip))
+        else:
+            self.assertEqual(len(result), 1)
         self.assertEqual((result[0][0], result[0][1]),
                          ('duplicate', newtip))
-        self.assertEqual((result[1][0], result[1][2]),
-                         ('duplicate id', newtip))
         transform2.finalize()
         transform3 = self.wt.transform()
         self.addCleanup(transform3.finalize)
@@ -874,80 +895,97 @@
         conflicts.delete_versioned(oz)
         emerald = conflicts.trans_id_tree_path('oz/emeraldcity')
         # set up MissingParent conflict
-        munchkincity = conflicts.trans_id_file_id(b'munchkincity-id')
+        if conflicts._tree.supports_setting_file_ids():
+            munchkincity = conflicts.trans_id_file_id(b'munchkincity-id')
+        else:
+            munchkincity = conflicts.assign_id()
         conflicts.adjust_path('munchkincity', root, munchkincity)
         conflicts.new_directory('auntem', munchkincity, b'auntem-id')
         # set up parent loop
         conflicts.adjust_path('emeraldcity', emerald, emerald)
-        return conflicts, emerald, oz, old_dorothy, new_dorothy
+        return conflicts, emerald, oz, old_dorothy, new_dorothy, munchkincity
 
     def test_conflict_resolution(self):
-        conflicts, emerald, oz, old_dorothy, new_dorothy =\
+        conflicts, emerald, oz, old_dorothy, new_dorothy, munchkincity =\
             self.get_conflicted()
         resolve_conflicts(conflicts)
         self.assertEqual(conflicts.final_name(old_dorothy), 'dorothy.moved')
-        self.assertIs(conflicts.final_file_id(old_dorothy), None)
+        if self.wt.supports_setting_file_ids():
+            self.assertIs(conflicts.final_file_id(old_dorothy), None)
+            self.assertEqual(conflicts.final_file_id(new_dorothy), b'dorothy-id')
         self.assertEqual(conflicts.final_name(new_dorothy), 'dorothy')
-        self.assertEqual(conflicts.final_file_id(new_dorothy), b'dorothy-id')
         self.assertEqual(conflicts.final_parent(emerald), oz)
         conflicts.apply()
 
     def test_cook_conflicts(self):
-        tt, emerald, oz, old_dorothy, new_dorothy = self.get_conflicted()
+        tt, emerald, oz, old_dorothy, new_dorothy, munchkincity = self.get_conflicted()
         raw_conflicts = resolve_conflicts(tt)
-        cooked_conflicts = tt.cook_conflicts(raw_conflicts)
-        duplicate = DuplicateEntry('Moved existing file to', 'dorothy.moved',
-                                   'dorothy', None, b'dorothy-id')
-        self.assertEqual(cooked_conflicts[0], duplicate)
-        duplicate_id = DuplicateID('Unversioned existing file',
-                                   'dorothy.moved', 'dorothy', None,
-                                   b'dorothy-id')
-        self.assertEqual(cooked_conflicts[1], duplicate_id)
-        missing_parent = MissingParent('Created directory', 'munchkincity',
-                                       b'munchkincity-id')
-        deleted_parent = DeletingParent('Not deleting', 'oz', b'oz-id')
-        self.assertEqual(cooked_conflicts[2], missing_parent)
-        unversioned_parent = UnversionedParent('Versioned directory',
-                                               'munchkincity',
-                                               b'munchkincity-id')
-        unversioned_parent2 = UnversionedParent('Versioned directory', 'oz',
-                                                b'oz-id')
-        self.assertEqual(cooked_conflicts[3], unversioned_parent)
-        parent_loop = ParentLoop(
-            'Cancelled move', 'oz/emeraldcity',
-            'oz/emeraldcity', b'emerald-id', b'emerald-id')
-        self.assertEqual(cooked_conflicts[4], deleted_parent)
-        self.assertEqual(cooked_conflicts[5], unversioned_parent2)
-        self.assertEqual(cooked_conflicts[6], parent_loop)
-        self.assertEqual(len(cooked_conflicts), 7)
+        cooked_conflicts = list(tt.cook_conflicts(raw_conflicts))
+        if self.wt.supports_setting_file_ids():
+            duplicate = DuplicateEntry('Moved existing file to', 'dorothy.moved',
+                                       'dorothy', None, b'dorothy-id')
+            self.assertEqual(cooked_conflicts[0], duplicate)
+            duplicate_id = DuplicateID('Unversioned existing file',
+                                       'dorothy.moved', 'dorothy', None,
+                                       b'dorothy-id')
+            self.assertEqual(cooked_conflicts[1], duplicate_id)
+            missing_parent = MissingParent('Created directory', 'munchkincity',
+                                           b'munchkincity-id')
+            deleted_parent = DeletingParent('Not deleting', 'oz', b'oz-id')
+            self.assertEqual(cooked_conflicts[2], missing_parent)
+            unversioned_parent = UnversionedParent('Versioned directory',
+                                                   'munchkincity',
+                                                   b'munchkincity-id')
+            unversioned_parent2 = UnversionedParent('Versioned directory', 'oz',
+                                                    b'oz-id')
+            self.assertEqual(cooked_conflicts[3], unversioned_parent)
+            parent_loop = ParentLoop(
+                'Cancelled move', 'oz/emeraldcity',
+                'oz/emeraldcity', b'emerald-id', b'emerald-id')
+            self.assertEqual(cooked_conflicts[4], deleted_parent)
+            self.assertEqual(cooked_conflicts[5], unversioned_parent2)
+            self.assertEqual(cooked_conflicts[6], parent_loop)
+            self.assertEqual(len(cooked_conflicts), 7)
+        else:
+            self.assertEqual(
+                set([c.path for c in cooked_conflicts]),
+                set(['oz/emeraldcity', 'oz', 'munchkincity', 'dorothy.moved']))
         tt.finalize()
 
     def test_string_conflicts(self):
-        tt, emerald, oz, old_dorothy, new_dorothy = self.get_conflicted()
+        tt, emerald, oz, old_dorothy, new_dorothy, munchkincity = self.get_conflicted()
         raw_conflicts = resolve_conflicts(tt)
-        cooked_conflicts = tt.cook_conflicts(raw_conflicts)
+        cooked_conflicts = list(tt.cook_conflicts(raw_conflicts))
         tt.finalize()
         conflicts_s = [text_type(c) for c in cooked_conflicts]
         self.assertEqual(len(cooked_conflicts), len(conflicts_s))
-        self.assertEqual(conflicts_s[0], 'Conflict adding file dorothy.  '
-                                         'Moved existing file to '
-                                         'dorothy.moved.')
-        self.assertEqual(conflicts_s[1], 'Conflict adding id to dorothy.  '
-                                         'Unversioned existing file '
-                                         'dorothy.moved.')
-        self.assertEqual(conflicts_s[2], 'Conflict adding files to'
-                                         ' munchkincity.  Created directory.')
-        self.assertEqual(conflicts_s[3], 'Conflict because munchkincity is not'
-                                         ' versioned, but has versioned'
-                                         ' children.  Versioned directory.')
-        self.assertEqualDiff(
-            conflicts_s[4], "Conflict: can't delete oz because it"
-                            " is not empty.  Not deleting.")
-        self.assertEqual(conflicts_s[5], 'Conflict because oz is not'
-                                         ' versioned, but has versioned'
-                                         ' children.  Versioned directory.')
-        self.assertEqual(conflicts_s[6], 'Conflict moving oz/emeraldcity into'
-                                         ' oz/emeraldcity. Cancelled move.')
+        if self.wt.supports_setting_file_ids():
+            self.assertEqual(conflicts_s[0], 'Conflict adding file dorothy.  '
+                                             'Moved existing file to '
+                                             'dorothy.moved.')
+            self.assertEqual(conflicts_s[1], 'Conflict adding id to dorothy.  '
+                                             'Unversioned existing file '
+                                             'dorothy.moved.')
+            self.assertEqual(conflicts_s[2], 'Conflict adding files to'
+                                             ' munchkincity.  Created directory.')
+            self.assertEqual(conflicts_s[3], 'Conflict because munchkincity is not'
+                                             ' versioned, but has versioned'
+                                             ' children.  Versioned directory.')
+            self.assertEqualDiff(
+                conflicts_s[4], "Conflict: can't delete oz because it"
+                                " is not empty.  Not deleting.")
+            self.assertEqual(conflicts_s[5], 'Conflict because oz is not'
+                                             ' versioned, but has versioned'
+                                             ' children.  Versioned directory.')
+            self.assertEqual(conflicts_s[6], 'Conflict moving oz/emeraldcity into'
+                                             ' oz/emeraldcity. Cancelled move.')
+        else:
+            self.assertEqual(
+                {'Text conflict in dorothy.moved',
+                 'Text conflict in munchkincity',
+                 'Text conflict in oz',
+                 'Text conflict in oz/emeraldcity'},
+                set([c for c in conflicts_s]))
 
     def prepare_wrong_parent_kind(self):
         tt, root = self.transform()
@@ -967,13 +1005,14 @@
         raw_conflicts = resolve_conflicts(tt)
         self.assertEqual({('non-directory parent', 'Created directory',
                            'new-3')}, raw_conflicts)
-        cooked_conflicts = tt.cook_conflicts(raw_conflicts)
-        if self.wt.supports_setting_file_ids():
+        cooked_conflicts = list(tt.cook_conflicts(raw_conflicts))
+        from ...bzr.workingtree import InventoryWorkingTree
+        if isinstance(tt._tree, InventoryWorkingTree):
             self.assertEqual([NonDirectoryParent('Created directory', 'parent.new',
                                                  b'parent-id')], cooked_conflicts)
         else:
-            self.assertEqual([NonDirectoryParent('Created directory', 'parent.new',
-                                                 None)], cooked_conflicts)
+            self.assertEqual(1, len(cooked_conflicts))
+            self.assertEqual('parent.new', cooked_conflicts[0].path)
         tt.apply()
         if self.wt.has_versioned_directories():
             self.assertFalse(self.wt.is_versioned('parent'))
@@ -1186,20 +1225,35 @@
         transform.apply()
         transform, root = self.transform()
         try:
-            self.assertEqual([], list(transform.iter_changes()))
+            self.assertTreeChanges(transform, [])
             old = transform.trans_id_tree_path('old')
             transform.unversion_file(old)
-            self.assertEqual([(b'id-1', ('old', None), False, (True, False),
-                               (root_id, root_id),
-                               ('old', 'old'), ('file', 'file'),
-                               (True, True), False)],
-                             list(transform.iter_changes()))
+            self.assertTreeChanges(
+                transform, [
+                    InventoryTreeChange(
+                        b'id-1', ('old', None), False, (True, False),
+                        (root_id, root_id), ('old', 'old'), ('file', 'file'),
+                        (True, True), False)])
             transform.new_directory('new', root, b'id-1')
-            self.assertEqual([(b'id-1', ('old', 'new'), True, (True, True),
-                               (root_id, root_id), ('old', 'new'),
-                               ('file', 'directory'),
-                               (True, False), False)],
-                             list(transform.iter_changes()))
+            if transform._tree.supports_setting_file_ids():
+                self.assertTreeChanges(
+                    transform,
+                    [InventoryTreeChange(
+                        b'id-1', ('old', 'new'), True, (True, True),
+                        (root_id, root_id), ('old', 'new'),
+                        ('file', 'directory'),
+                        (True, False), False)])
+            else:
+                self.assertTreeChanges(
+                    transform,
+                    [TreeChange(
+                        (None, 'new'), False, (False, True),
+                        (None, 'new'), (None, 'directory'),
+                        (False, False), False),
+                     TreeChange(
+                        ('old', None), False, (True, False),
+                        ('old', 'old'), ('file', 'file'),
+                        (True, True), False)])
         finally:
             transform.finalize()
 
@@ -1212,11 +1266,15 @@
         try:
             old = transform.trans_id_tree_path('old')
             transform.version_file(old, file_id=b'id-1')
-            self.assertEqual([(b'id-1', (None, 'old'), False, (False, True),
-                               (root_id, root_id),
-                               ('old', 'old'), ('file', 'file'),
-                               (False, False), False)],
-                             list(transform.iter_changes()))
+            changes = list(transform.iter_changes())
+            self.assertEqual(1, len(changes))
+            self.assertEqual((None, 'old'), changes[0].path)
+            self.assertEqual(False, changes[0].changed_content)
+            self.assertEqual((False, True), changes[0].versioned)
+            self.assertEqual((False, False), changes[0].executable)
+            if self.wt.supports_setting_file_ids():
+                self.assertEqual((root_id, root_id), changes[0].parent_id)
+                self.assertEqual(b'id-1', changes[0].file_id)
         finally:
             transform.finalize()
 
@@ -1232,78 +1290,120 @@
             old = transform.trans_id_tree_path('old')
             subdir = transform.trans_id_tree_path('subdir')
             new = transform.trans_id_tree_path('new')
-            self.assertEqual([], list(transform.iter_changes()))
+            self.assertTreeChanges(transform, [])
 
             # content deletion
             transform.delete_contents(old)
-            self.assertEqual([(b'id-1', ('old', 'old'), True, (True, True),
-                               (root_id, root_id),
-                               ('old', 'old'), ('file', None),
-                               (False, False), False)],
-                             list(transform.iter_changes()))
+            self.assertTreeChanges(
+                transform,
+                [InventoryTreeChange(
+                    b'id-1', ('old', 'old'), True, (True, True),
+                    (root_id, root_id),
+                    ('old', 'old'), ('file', None),
+                    (False, False), False)])
 
             # content change
             transform.create_file([b'blah'], old)
-            self.assertEqual([(b'id-1', ('old', 'old'), True, (True, True),
-                               (root_id, root_id),
-                               ('old', 'old'), ('file', 'file'),
-                               (False, False), False)],
-                             list(transform.iter_changes()))
+            self.assertTreeChanges(
+                transform,
+                [InventoryTreeChange(
+                    b'id-1', ('old', 'old'), True, (True, True),
+                    (root_id, root_id),
+                    ('old', 'old'), ('file', 'file'),
+                    (False, False), False)])
             transform.cancel_deletion(old)
-            self.assertEqual([(b'id-1', ('old', 'old'), True, (True, True),
-                               (root_id, root_id),
-                               ('old', 'old'), ('file', 'file'),
-                               (False, False), False)],
-                             list(transform.iter_changes()))
+            self.assertTreeChanges(
+                transform,
+                [InventoryTreeChange(
+                    b'id-1', ('old', 'old'), True, (True, True),
+                    (root_id, root_id),
+                    ('old', 'old'), ('file', 'file'),
+                    (False, False), False)])
             transform.cancel_creation(old)
 
             # move file_id to a different file
-            self.assertEqual([], list(transform.iter_changes()))
+            self.assertTreeChanges(transform, [])
             transform.unversion_file(old)
             transform.version_file(new, file_id=b'id-1')
             transform.adjust_path('old', root, new)
-            self.assertEqual([(b'id-1', ('old', 'old'), True, (True, True),
-                               (root_id, root_id),
-                               ('old', 'old'), ('file', 'file'),
-                               (False, False), False)],
-                             list(transform.iter_changes()))
+            if transform._tree.supports_setting_file_ids():
+                self.assertTreeChanges(
+                    transform,
+                    [InventoryTreeChange(
+                        b'id-1', ('old', 'old'), True, (True, True),
+                        (root_id, root_id),
+                        ('old', 'old'), ('file', 'file'),
+                        (False, False), False)])
+            else:
+                self.assertTreeChanges(
+                    transform,
+                    [TreeChange(
+                        (None, 'old'), False, (False, True),
+                        (None, 'old'), (None, 'file'), (False, False), False),
+                     TreeChange(
+                         ('old', None), False, (True, False), ('old', 'old'),
+                         ('file', 'file'), (False, False), False)])
+
             transform.cancel_versioning(new)
             transform._removed_id = set()
 
             # execute bit
-            self.assertEqual([], list(transform.iter_changes()))
+            self.assertTreeChanges(transform, [])
             transform.set_executability(True, old)
-            self.assertEqual([(b'id-1', ('old', 'old'), False, (True, True),
-                               (root_id, root_id),
-                               ('old', 'old'), ('file', 'file'),
-                               (False, True), False)],
-                             list(transform.iter_changes()))
+            self.assertTreeChanges(
+                transform,
+                [InventoryTreeChange(
+                    b'id-1', ('old', 'old'), False, (True, True),
+                    (root_id, root_id),
+                    ('old', 'old'), ('file', 'file'),
+                    (False, True), False)])
             transform.set_executability(None, old)
 
             # filename
-            self.assertEqual([], list(transform.iter_changes()))
+            self.assertTreeChanges(transform, [])
             transform.adjust_path('new', root, old)
             transform._new_parent = {}
-            self.assertEqual([(b'id-1', ('old', 'new'), False, (True, True),
-                               (root_id, root_id),
-                               ('old', 'new'), ('file', 'file'),
-                               (False, False), False)],
-                             list(transform.iter_changes()))
+            self.assertTreeChanges(
+                transform,
+                [InventoryTreeChange(
+                    b'id-1', ('old', 'new'), False, (True, True),
+                    (root_id, root_id),
+                    ('old', 'new'), ('file', 'file'),
+                    (False, False), False)])
             transform._new_name = {}
 
             # parent directory
-            self.assertEqual([], list(transform.iter_changes()))
+            self.assertTreeChanges(transform, [])
             transform.adjust_path('new', subdir, old)
             transform._new_name = {}
-            self.assertEqual([(b'id-1', ('old', 'subdir/old'), False,
-                               (True, True), (root_id, b'subdir-id'), ('old', 'old'),
-                               ('file', 'file'), (False, False), False)],
-                             list(transform.iter_changes()))
+            self.assertTreeChanges(
+                transform, [
+                    InventoryTreeChange(
+                        b'id-1', ('old', 'subdir/old'), False,
+                        (True, True), (root_id, b'subdir-id'), ('old', 'old'),
+                        ('file', 'file'), (False, False), False)])
             transform._new_path = {}
-
         finally:
             transform.finalize()
 
+    def assertTreeChanges(self, tt, expected):
+        # TODO(jelmer): Turn this into a matcher?
+        actual = list(tt.iter_changes())
+        if tt._tree.supports_setting_file_ids():
+            self.assertEqual(expected, actual)
+        else:
+            expected = [
+                TreeChange(path=c.path, changed_content=c.changed_content,
+                           versioned=c.versioned, name=c.name,
+                           kind=c.kind, executable=c.executable,
+                           copied=c.copied) for c in expected]
+            actual = [
+                TreeChange(path=c.path, changed_content=c.changed_content,
+                           versioned=c.versioned, name=c.name,
+                           kind=c.kind, executable=c.executable,
+                           copied=c.copied) for c in actual]
+            self.assertEqual(expected, actual)
+
     def test_iter_changes_modified_bleed(self):
         root_id = self.wt.path2id('')
         """Modified flag should not bleed from one change to another"""
@@ -1317,17 +1417,17 @@
         transform.apply()
         transform, root = self.transform()
         try:
-            transform.delete_contents(transform.trans_id_file_id(b'id-1'))
-            transform.set_executability(True,
-                                        transform.trans_id_file_id(b'id-2'))
-            self.assertEqual(
-                [(b'id-1', (u'file1', u'file1'), True, (True, True),
-                 (root_id, root_id), ('file1', u'file1'),
-                 ('file', None), (False, False), False),
-                 (b'id-2', (u'file2', u'file2'), False, (True, True),
-                 (root_id, root_id), ('file2', u'file2'),
-                 ('file', 'file'), (False, True), False)],
-                list(transform.iter_changes()))
+            transform.delete_contents(transform.trans_id_tree_path('file1'))
+            transform.set_executability(True, transform.trans_id_tree_path('file2'))
+            self.assertTreeChanges(transform, [
+                InventoryTreeChange(
+                b'id-1', (u'file1', u'file1'), True, (True, True),
+                (root_id, root_id), ('file1', u'file1'),
+                ('file', None), (False, False), False),
+                InventoryTreeChange(
+                b'id-2', (u'file2', u'file2'), False, (True, True),
+                (root_id, root_id), ('file2', u'file2'),
+                ('file', 'file'), (False, True), False)])
         finally:
             transform.finalize()
 
@@ -1345,12 +1445,17 @@
         floater = transform.trans_id_tree_path('floater')
         try:
             transform.adjust_path('flitter', root, floater)
-            self.assertEqual([(b'floater-id', ('floater', 'flitter'), False,
-                               (True, True),
-                               (root_id, root_id),
-                               ('floater', 'flitter'),
-                               (None, None), (False, False), False)],
-                             list(transform.iter_changes()))
+            if self.wt.has_versioned_directories():
+                self.assertTreeChanges(
+                    transform,
+                    [InventoryTreeChange(
+                        b'floater-id', ('floater', 'flitter'), False,
+                        (True, True),
+                        (root_id, root_id),
+                        ('floater', 'flitter'),
+                        (None, None), (False, False), False)])
+            else:
+                self.assertTreeChanges(transform, [])
         finally:
             transform.finalize()
 
@@ -1364,14 +1469,14 @@
         try:
             old = transform.trans_id_tree_path('old')
             subdir = transform.trans_id_tree_path('subdir')
-            self.assertEqual([], list(transform.iter_changes()))
+            self.assertTreeChanges(transform, [])
             transform.delete_contents(subdir)
             transform.create_directory(subdir)
             transform.set_executability(False, old)
             transform.unversion_file(old)
             transform.version_file(old, file_id=b'id-1')
             transform.adjust_path('old', root, old)
-            self.assertEqual([], list(transform.iter_changes()))
+            self.assertTreeChanges(transform, [])
         finally:
             transform.finalize()
 

=== modified file 'breezy/tests/per_workingtree/test_unversion.py'
--- breezy/tests/per_workingtree/test_unversion.py	2020-08-10 03:38:37 +0000
+++ breezy/tests/per_workingtree/test_unversion.py	2020-08-20 19:27:58 +0000
@@ -179,7 +179,7 @@
         if tree_b.has_versioned_directories():
             self.assertEqual(4, num_conflicts)
         else:
-            self.assertEqual(3, num_conflicts)
+            self.assertEqual(1, num_conflicts)
 
         self.assertThat(
             tree_b,

=== modified file 'breezy/tests/per_workingtree/test_workingtree.py'
--- breezy/tests/per_workingtree/test_workingtree.py	2020-08-10 00:21:26 +0000
+++ breezy/tests/per_workingtree/test_workingtree.py	2020-08-20 19:27:58 +0000
@@ -216,13 +216,11 @@
     def test_lock_locks_branch(self):
         tree = self.make_branch_and_tree('.')
         self.assertEqual(None, tree.branch.peek_lock_mode())
-        tree.lock_read()
-        self.assertEqual('r', tree.branch.peek_lock_mode())
-        tree.unlock()
+        with tree.lock_read():
+            self.assertEqual('r', tree.branch.peek_lock_mode())
         self.assertEqual(None, tree.branch.peek_lock_mode())
-        tree.lock_write()
-        self.assertEqual('w', tree.branch.peek_lock_mode())
-        tree.unlock()
+        with tree.lock_write():
+            self.assertEqual('w', tree.branch.peek_lock_mode())
         self.assertEqual(None, tree.branch.peek_lock_mode())
 
     def test_revert(self):
@@ -1013,6 +1011,16 @@
         if tree.branch.repository._format.supports_versioned_directories:
             self.assertEqual('directory', tree.stored_kind('b'))
 
+    def test_stored_kind_nonexistent(self):
+        tree = self.make_branch_and_tree('tree')
+        tree.lock_write()
+        self.assertRaises(errors.NoSuchFile, tree.stored_kind, 'a')
+        self.addCleanup(tree.unlock)
+        self.build_tree(['tree/a'])
+        self.assertRaises(errors.NoSuchFile, tree.stored_kind, 'a')
+        tree.add(['a'])
+        self.assertIs('file', tree.stored_kind('a'))
+
     def test_missing_file_sha1(self):
         """If a file is missing, its sha1 should be reported as None."""
         tree = self.make_branch_and_tree('.')

=== modified file 'breezy/transform.py'
--- breezy/transform.py	2020-08-14 20:01:27 +0000
+++ breezy/transform.py	2020-08-20 19:27:58 +0000
@@ -355,6 +355,8 @@
             contents insertion command)
         """
         if trans_id in self._new_contents:
+            if trans_id in self._new_reference_revision:
+                return 'tree-reference'
             return self._new_contents[trans_id]
         elif trans_id in self._removed_contents:
             return None
@@ -1238,7 +1240,11 @@
 def resolve_non_directory_parent(tt, path_tree, c_type, parent_id):
     parent_parent = tt.final_parent(parent_id)
     parent_name = tt.final_name(parent_id)
-    parent_file_id = tt.final_file_id(parent_id)
+    # TODO(jelmer): Make this code transform-specific
+    if tt._tree.supports_setting_file_ids():
+        parent_file_id = tt.final_file_id(parent_id)
+    else:
+        parent_file_id = b'DUMMY'
     new_parent_id = tt.new_directory(parent_name + '.new',
                                      parent_parent, parent_file_id)
     _reparent_transform_children(tt, parent_id, new_parent_id)
@@ -1359,6 +1365,9 @@
         self._all_children_cache = {}
         self._final_name_cache = {}
 
+    def supports_setting_file_ids(self):
+        raise NotImplementedError(self.supports_setting_file_ids)
+
     @property
     def _by_parent(self):
         if self.__by_parent is None:

=== modified file 'breezy/workingtree.py'
--- breezy/workingtree.py	2020-08-09 18:10:01 +0000
+++ breezy/workingtree.py	2020-08-20 19:27:58 +0000
@@ -711,8 +711,12 @@
 
     def get_symlink_target(self, path):
         abspath = self.abspath(path)
-        target = osutils.readlink(abspath)
-        return target
+        try:
+            return osutils.readlink(abspath)
+        except OSError as e:
+            if getattr(e, 'errno', None) == errno.ENOENT:
+                raise errors.NoSuchFile(path)
+            raise
 
     def subsume(self, other_tree):
         raise NotImplementedError(self.subsume)