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

[Jelmer Vernooij]

Split out git and bzr-specific transform.

Split out git and bzr-specific transform.

[Jelmer Vernooij (jelmer)]

review: Approve

=== modified file 'breezy/bzr/transform.py'
--- breezy/bzr/transform.py	2020-07-05 19:02:14 +0000
+++ breezy/bzr/transform.py	2020-07-06 02:29:08 +0000
@@ -19,14 +19,17 @@
 
 import errno
 import os
-from stat import S_IEXEC
+from stat import S_IEXEC, S_ISREG
+import time
 
 from .. import (
     annotate,
     errors,
     lock,
+    multiparent,
     osutils,
     revision as _mod_revision,
+    trace,
     tree,
     ui,
     urlutils,
@@ -39,19 +42,1209 @@
     ROOT_PARENT,
     _FileMover,
     _TransformResults,
-    DiskTreeTransform,
     joinpath,
     NoFinalPath,
     FinalPaths,
     unique_add,
+    TreeTransform,
     TransformRenameFailed,
+    ImmortalLimbo,
+    ReusingTransform,
+    MalformedTransform,
     )
+from ..tree import TreeChange
 from . import (
     inventory,
     inventorytree,
     )
 
 
+class TreeTransformBase(TreeTransform):
+    """The base class for TreeTransform and its kin."""
+
+    def __init__(self, tree, pb=None, case_sensitive=True):
+        """Constructor.
+
+        :param tree: The tree that will be transformed, but not necessarily
+            the output tree.
+        :param pb: ignored
+        :param case_sensitive: If True, the target of the transform is
+            case sensitive, not just case preserving.
+        """
+        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 = {}
+        # 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
+        # Whether the target is case sensitive
+        self._case_sensitive_target = case_sensitive
+
+    def finalize(self):
+        """Release the working tree lock, if held.
+
+        This is required if apply has not been invoked, but can be invoked
+        even after apply.
+        """
+        if self._tree is None:
+            return
+        for hook in MutableTree.hooks['post_transform']:
+            hook(self._tree, self)
+        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()
+        unique_add(self._new_name, trans_id, name)
+        unique_add(self._new_parent, trans_id, parent)
+        return trans_id
+
+    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
+
+        Instead of creating a root directory, or moving an existing directory,
+        all the attributes and children of the new root are applied to the
+        existing root directory.
+
+        This means that the old root trans-id becomes obsolete, so it is
+        recommended only to invoke this after the root trans-id has become
+        irrelevant.
+
+        """
+        new_roots = [k for k, v in viewitems(self._new_parent)
+                     if v == ROOT_PARENT]
+        if len(new_roots) < 1:
+            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:
+            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
+        # use directly-- some tree children have new parents
+        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)
+
+        # Ensure old_new_root has no directory.
+        if old_new_root in self._new_contents:
+            self.cancel_creation(old_new_root)
+        else:
+            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)
+
+        # destroy path info for old_new_root.
+        del self._new_parent[old_new_root]
+        del self._new_name[old_new_root]
+
+    def trans_id_file_id(self, file_id):
+        """Determine or set the transaction id associated with a file ID.
+        A new id is only created for file_ids that were never present.  If
+        a transaction has been unversioned, it is deliberately still returned.
+        (this will likely lead to an unversioned parent conflict.)
+        """
+        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)
+
+    def version_file(self, trans_id, file_id=None):
+        """Schedule a file to become versioned."""
+        raise NotImplementedError(self.version_file)
+
+    def cancel_versioning(self, trans_id):
+        """Undo a previous versioning of a file"""
+        raise NotImplementedError(self.cancel_versioning)
+
+    def new_paths(self, filesystem_only=False):
+        """Determine the paths of all new and changed files.
+
+        :param filesystem_only: if True, only calculate values for files
+            that require renames or execute bit changes.
+        """
+        new_ids = set()
+        if filesystem_only:
+            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)
+            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)
+        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
+
+    def find_conflicts(self):
+        """Find any violations of inventory or filesystem invariants"""
+        if self._done is True:
+            raise ReusingTransform()
+        conflicts = []
+        # ensure all children of all existent parents are known
+        # all children of non-existent parents are known, by definition.
+        self._add_tree_children()
+        by_parent = self.by_parent()
+        conflicts.extend(self._unversioned_parents(by_parent))
+        conflicts.extend(self._parent_loops())
+        conflicts.extend(self._duplicate_entries(by_parent))
+        conflicts.extend(self._parent_type_conflicts(by_parent))
+        conflicts.extend(self._improper_versioning())
+        conflicts.extend(self._executability_conflicts())
+        conflicts.extend(self._overwrite_conflicts())
+        return conflicts
+
+    def _check_malformed(self):
+        conflicts = self.find_conflicts()
+        if len(conflicts) != 0:
+            raise MalformedTransform(conflicts=conflicts)
+
+    def _add_tree_children(self):
+        """Add all the children of all active parents to the known paths.
+
+        Active parents are those which gain children, and those which are
+        removed.  This is a necessary first step in detecting conflicts.
+        """
+        parents = list(self.by_parent())
+        parents.extend([t for t in self._removed_contents if
+                        self.tree_kind(t) == 'directory'])
+        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)
+            elif self.tree_kind(trans_id) == 'directory':
+                parents.append(trans_id)
+
+        for parent_id in parents:
+            # ensure that all children are registered with the transaction
+            list(self.iter_tree_children(parent_id))
+
+    def _has_named_child(self, name, parent_id, known_children):
+        """Does a parent already have a name child.
+
+        :param name: The searched for name.
+
+        :param parent_id: The parent for which the check is made.
+
+        :param known_children: The already known children. This should have
+            been recently obtained from `self.by_parent.get(parent_id)`
+            (or will be if None is passed).
+        """
+        if known_children is None:
+            known_children = self.by_parent().get(parent_id, [])
+        for child in known_children:
+            if self.final_name(child) == name:
+                return True
+        parent_path = self._tree_id_paths.get(parent_id, None)
+        if parent_path is None:
+            # No parent... no children
+            return False
+        child_path = joinpath(parent_path, name)
+        child_id = self._tree_path_ids.get(child_path, None)
+        if child_id is None:
+            # Not known by the tree transform yet, check the filesystem
+            return osutils.lexists(self._tree.abspath(child_path))
+        else:
+            raise AssertionError('child_id is missing: %s, %s, %s'
+                                 % (name, parent_id, child_id))
+
+    def _available_backup_name(self, name, target_id):
+        """Find an available backup name.
+
+        :param name: The basename of the file.
+
+        :param target_id: The directory trans_id where the backup should
+            be placed.
+        """
+        known_children = self.by_parent().get(target_id, [])
+        return osutils.available_backup_name(
+            name,
+            lambda base: self._has_named_child(
+                base, target_id, known_children))
+
+    def _parent_loops(self):
+        """No entry should be its own ancestor"""
+        conflicts = []
+        for trans_id in self._new_parent:
+            seen = set()
+            parent_id = trans_id
+            while parent_id != ROOT_PARENT:
+                seen.add(parent_id)
+                try:
+                    parent_id = self.final_parent(parent_id)
+                except KeyError:
+                    break
+                if parent_id == trans_id:
+                    conflicts.append(('parent loop', trans_id))
+                if parent_id in seen:
+                    break
+        return conflicts
+
+    def _unversioned_parents(self, by_parent):
+        """If parent directories are versioned, children must be versioned."""
+        conflicts = []
+        for parent_id, children in viewitems(by_parent):
+            if parent_id == ROOT_PARENT:
+                continue
+            if self.final_is_versioned(parent_id):
+                continue
+            for child_id in children:
+                if self.final_is_versioned(child_id):
+                    conflicts.append(('unversioned parent', parent_id))
+                    break
+        return conflicts
+
+    def _improper_versioning(self):
+        """Cannot version a file with no contents, or a bad type.
+
+        However, existing entries with no contents are okay.
+        """
+        conflicts = []
+        for trans_id in self._new_id:
+            kind = self.final_kind(trans_id)
+            if kind == 'symlink' and not self._tree.supports_symlinks():
+                # Ignore symlinks as they are not supported on this platform
+                continue
+            if kind is None:
+                conflicts.append(('versioning no contents', trans_id))
+                continue
+            if not self._tree.versionable_kind(kind):
+                conflicts.append(('versioning bad kind', trans_id, kind))
+        return conflicts
+
+    def _executability_conflicts(self):
+        """Check for bad executability changes.
+
+        Only versioned files may have their executability set, because
+        1. only versioned entries can have executability under windows
+        2. only files can be executable.  (The execute bit on a directory
+           does not indicate searchability)
+        """
+        conflicts = []
+        for trans_id in self._new_executability:
+            if not self.final_is_versioned(trans_id):
+                conflicts.append(('unversioned executability', trans_id))
+            else:
+                if self.final_kind(trans_id) != "file":
+                    conflicts.append(('non-file executability', trans_id))
+        return conflicts
+
+    def _overwrite_conflicts(self):
+        """Check for overwrites (not permitted on Win32)"""
+        conflicts = []
+        for trans_id in self._new_contents:
+            if self.tree_kind(trans_id) is None:
+                continue
+            if trans_id not in self._removed_contents:
+                conflicts.append(('overwrite', trans_id,
+                                  self.final_name(trans_id)))
+        return conflicts
+
+    def _duplicate_entries(self, by_parent):
+        """No directory may have two entries with the same name."""
+        conflicts = []
+        if (self._new_name, self._new_parent) == ({}, {}):
+            return conflicts
+        for children in viewvalues(by_parent):
+            name_ids = []
+            for child_tid in children:
+                name = self.final_name(child_tid)
+                if name is not None:
+                    # Keep children only if they still exist in the end
+                    if not self._case_sensitive_target:
+                        name = name.lower()
+                    name_ids.append((name, child_tid))
+            name_ids.sort()
+            last_name = None
+            last_trans_id = None
+            for name, trans_id in name_ids:
+                kind = self.final_kind(trans_id)
+                if kind is None and not self.final_is_versioned(trans_id):
+                    continue
+                if name == last_name:
+                    conflicts.append(('duplicate', last_trans_id, trans_id,
+                                      name))
+                last_name = name
+                last_trans_id = trans_id
+        return conflicts
+
+    def _parent_type_conflicts(self, by_parent):
+        """Children must have a directory parent"""
+        conflicts = []
+        for parent_id, children in viewitems(by_parent):
+            if parent_id == ROOT_PARENT:
+                continue
+            no_children = True
+            for child_id in children:
+                if self.final_kind(child_id) is not None:
+                    no_children = False
+                    break
+            if no_children:
+                continue
+            # There is at least a child, so we need an existing directory to
+            # contain it.
+            kind = self.final_kind(parent_id)
+            if kind is None:
+                # The directory will be deleted
+                conflicts.append(('missing parent', parent_id))
+            elif kind != "directory":
+                # Meh, we need a *directory* to put something in it
+                conflicts.append(('non-directory parent', parent_id))
+        return conflicts
+
+    def _set_executability(self, path, trans_id):
+        """Set the executability of versioned files """
+        if self._tree._supports_executable():
+            new_executability = self._new_executability[trans_id]
+            abspath = self._tree.abspath(path)
+            current_mode = os.stat(abspath).st_mode
+            if new_executability:
+                umask = os.umask(0)
+                os.umask(umask)
+                to_mode = current_mode | (0o100 & ~umask)
+                # Enable x-bit for others only if they can read it.
+                if current_mode & 0o004:
+                    to_mode |= 0o001 & ~umask
+                if current_mode & 0o040:
+                    to_mode |= 0o010 & ~umask
+            else:
+                to_mode = current_mode & ~0o111
+            osutils.chmod_if_possible(abspath, to_mode)
+
+    def _new_entry(self, name, parent_id, file_id):
+        """Helper function to create a new filesystem entry."""
+        trans_id = self.create_path(name, parent_id)
+        if file_id is not None:
+            self.version_file(trans_id, file_id=file_id)
+        return trans_id
+
+    def new_file(self, name, parent_id, contents, file_id=None,
+                 executable=None, sha1=None):
+        """Convenience method to create files.
+
+        name is the name of the file to create.
+        parent_id is the transaction id of the parent directory of the file.
+        contents is an iterator of bytestrings, which will be used to produce
+        the file.
+        :param file_id: The inventory ID of the file, if it is to be versioned.
+        :param executable: Only valid when a file_id has been supplied.
+        """
+        trans_id = self._new_entry(name, parent_id, file_id)
+        # TODO: rather than scheduling a set_executable call,
+        # have create_file create the file with the right mode.
+        self.create_file(contents, trans_id, sha1=sha1)
+        if executable is not None:
+            self.set_executability(executable, trans_id)
+        return trans_id
+
+    def new_directory(self, name, parent_id, file_id=None):
+        """Convenience method to create directories.
+
+        name is the name of the directory to create.
+        parent_id is the transaction id of the parent directory of the
+        directory.
+        file_id is the inventory ID of the directory, if it is to be versioned.
+        """
+        trans_id = self._new_entry(name, parent_id, file_id)
+        self.create_directory(trans_id)
+        return trans_id
+
+    def new_symlink(self, name, parent_id, target, file_id=None):
+        """Convenience method to create symbolic link.
+
+        name is the name of the symlink to create.
+        parent_id is the transaction id of the parent directory of the symlink.
+        target is a bytestring of the target of the symlink.
+        file_id is the inventory ID of the file, if it is to be versioned.
+        """
+        trans_id = self._new_entry(name, parent_id, file_id)
+        self.create_symlink(target, trans_id)
+        return trans_id
+
+    def new_orphan(self, trans_id, parent_id):
+        """Schedule an item to be orphaned.
+
+        When a directory is about to be removed, its children, if they are not
+        versioned are moved out of the way: they don't have a parent anymore.
+
+        :param trans_id: The trans_id of the existing item.
+        :param parent_id: The parent trans_id of the item.
+        """
+        raise NotImplementedError(self.new_orphan)
+
+    def _get_potential_orphans(self, dir_id):
+        """Find the potential orphans in a directory.
+
+        A directory can't be safely deleted if there are versioned files in it.
+        If all the contained files are unversioned then they can be orphaned.
+
+        The 'None' return value means that the directory contains at least one
+        versioned file and should not be deleted.
+
+        :param dir_id: The directory trans id.
+
+        :return: A list of the orphan trans ids or None if at least one
+             versioned file is present.
+        """
+        orphans = []
+        # Find the potential orphans, stop if one item should be kept
+        for child_tid in self.by_parent()[dir_id]:
+            if child_tid in self._removed_contents:
+                # The child is removed as part of the transform. Since it was
+                # versioned before, it's not an orphan
+                continue
+            if not self.final_is_versioned(child_tid):
+                # The child is not versioned
+                orphans.append(child_tid)
+            else:
+                # We have a versioned file here, searching for orphans is
+                # meaningless.
+                orphans = None
+                break
+        return orphans
+
+    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._removed_contents)
+        trans_ids.update(self._new_contents)
+        trans_ids.update(self._new_executability)
+        trans_ids.update(self._new_name)
+        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):
+        """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_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()
+        results = []
+        # Now iterate through all active file_ids
+        for file_id in set(from_trans_ids).union(to_trans_ids):
+            modified = False
+            from_trans_id = from_trans_ids.get(file_id)
+            # find file ids, and determine versioning state
+            if from_trans_id 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:
+                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:
+                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:
+                modified = True
+            elif to_kind in ('file', 'symlink') and (
+                    to_trans_id != from_trans_id
+                    or to_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_executable == to_executable):
+                continue
+            results.append(
+                TreeChange(
+                    file_id, (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)))
+
+        def path_key(c):
+            return (c.path[0] or '', c.path[1] or '')
+        return iter(sorted(results, key=path_key))
+
+    def get_preview_tree(self):
+        """Return a tree representing the result of the transform.
+
+        The tree is a snapshot, and altering the TreeTransform will invalidate
+        it.
+        """
+        raise NotImplementedError(self.get_preview)
+
+    def commit(self, branch, message, merge_parents=None, strict=False,
+               timestamp=None, timezone=None, committer=None, authors=None,
+               revprops=None, revision_id=None):
+        """Commit the result of this TreeTransform to a branch.
+
+        :param branch: The branch to commit to.
+        :param message: The message to attach to the commit.
+        :param merge_parents: Additional parent revision-ids specified by
+            pending merges.
+        :param strict: If True, abort the commit if there are unversioned
+            files.
+        :param timestamp: if not None, seconds-since-epoch for the time and
+            date.  (May be a float.)
+        :param timezone: Optional timezone for timestamp, as an offset in
+            seconds.
+        :param committer: Optional committer in email-id format.
+            (e.g. "J Random Hacker <[e-mail]>")
+        :param authors: Optional list of authors in email-id format.
+        :param revprops: Optional dictionary of revision properties.
+        :param revision_id: Optional revision id.  (Specifying a revision-id
+            may reduce performance for some non-native formats.)
+        :return: The revision_id of the revision committed.
+        """
+        self._check_malformed()
+        if strict:
+            unversioned = set(self._new_contents).difference(set(self._new_id))
+            for trans_id in unversioned:
+                if not self.final_is_versioned(trans_id):
+                    raise errors.StrictCommitFailed()
+
+        revno, last_rev_id = branch.last_revision_info()
+        if last_rev_id == _mod_revision.NULL_REVISION:
+            if merge_parents is not None:
+                raise ValueError('Cannot supply merge parents for first'
+                                 ' commit.')
+            parent_ids = []
+        else:
+            parent_ids = [last_rev_id]
+            if merge_parents is not None:
+                parent_ids.extend(merge_parents)
+        if self._tree.get_revision_id() != last_rev_id:
+            raise ValueError('TreeTransform not based on branch basis: %s' %
+                             self._tree.get_revision_id().decode('utf-8'))
+        from .. import commit
+        revprops = commit.Commit.update_revprops(revprops, branch, authors)
+        builder = branch.get_commit_builder(parent_ids,
+                                            timestamp=timestamp,
+                                            timezone=timezone,
+                                            committer=committer,
+                                            revprops=revprops,
+                                            revision_id=revision_id)
+        preview = self.get_preview_tree()
+        list(builder.record_iter_changes(preview, last_rev_id,
+                                         self.iter_changes()))
+        builder.finish_inventory()
+        revision_id = builder.commit(message)
+        branch.set_last_revision_info(revno + 1, revision_id)
+        return revision_id
+
+    def _text_parent(self, trans_id):
+        path = self.tree_path(trans_id)
+        try:
+            if path is None or self._tree.kind(path) != 'file':
+                return None
+        except errors.NoSuchFile:
+            return None
+        return path
+
+    def _get_parents_texts(self, trans_id):
+        """Get texts for compression parents of this file."""
+        path = self._text_parent(trans_id)
+        if path is None:
+            return ()
+        return (self._tree.get_file_text(path),)
+
+    def _get_parents_lines(self, trans_id):
+        """Get lines for compression parents of this file."""
+        path = self._text_parent(trans_id)
+        if path is None:
+            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.
+
+        :seealso: new_file.
+
+        :param contents: an iterator of strings, all of which will be written
+            to the target destination.
+        :param trans_id: TreeTransform handle
+        :param mode_id: If not None, force the mode of the target file to match
+            the mode of the object referenced by mode_id.
+            Otherwise, we will try to preserve mode bits of an existing file.
+        :param sha1: If the sha1 of this content is already known, pass it in.
+            We can use it to prevent future sha1 computations.
+        """
+        raise NotImplementedError(self.create_file)
+
+    def create_directory(self, trans_id):
+        """Schedule creation of a new directory.
+
+        See also new_directory.
+        """
+        raise NotImplementedError(self.create_directory)
+
+    def create_symlink(self, target, trans_id):
+        """Schedule creation of a new symbolic link.
+
+        target is a bytestring.
+        See also new_symlink.
+        """
+        raise NotImplementedError(self.create_symlink)
+
+    def create_hardlink(self, path, trans_id):
+        """Schedule creation of a hard link"""
+        raise NotImplementedError(self.create_hardlink)
+
+    def cancel_creation(self, trans_id):
+        """Cancel the creation of new file contents."""
+        raise NotImplementedError(self.cancel_creation)
+
+    def apply(self, no_conflicts=False, precomputed_delta=None, _mover=None):
+        """Apply all changes to the inventory and filesystem.
+
+        If filesystem or inventory conflicts are present, MalformedTransform
+        will be thrown.
+
+        If apply succeeds, finalize is not necessary.
+
+        :param no_conflicts: if True, the caller guarantees there are no
+            conflicts, so no check is made.
+        :param precomputed_delta: An inventory delta to use instead of
+            calculating one.
+        :param _mover: Supply an alternate FileMover, for testing
+        """
+        raise NotImplementedError(self.apply)
+
+
+class DiskTreeTransform(TreeTransformBase):
+    """Tree transform storing its contents on disk."""
+
+    def __init__(self, tree, limbodir, pb=None, case_sensitive=True):
+        """Constructor.
+        :param tree: The tree that will be transformed, but not necessarily
+            the output tree.
+        :param limbodir: A directory where new files can be stored until
+            they are installed in their proper places
+        :param pb: ignored
+        :param case_sensitive: If True, the target of the transform is
+            case sensitive, not just case preserving.
+        """
+        TreeTransformBase.__init__(self, tree, pb, case_sensitive)
+        self._limbodir = limbodir
+        self._deletiondir = None
+        # A mapping of transform ids to their limbo filename
+        self._limbo_files = {}
+        self._possibly_stale_limbo_files = set()
+        # A mapping of transform ids to a set of the transform ids of children
+        # that their limbo directory has
+        self._limbo_children = {}
+        # Map transform ids to maps of child filename to child transform id
+        self._limbo_children_names = {}
+        # List of transform ids that need to be renamed from limbo into place
+        self._needs_rename = set()
+        self._creation_mtime = None
+        self._create_symlinks = osutils.supports_symlinks(self._limbodir)
+
+    def finalize(self):
+        """Release the working tree lock, if held, clean up limbo dir.
+
+        This is required if apply has not been invoked, but can be invoked
+        even after apply.
+        """
+        if self._tree is None:
+            return
+        try:
+            limbo_paths = list(viewvalues(self._limbo_files))
+            limbo_paths.extend(self._possibly_stale_limbo_files)
+            limbo_paths.sort(reverse=True)
+            for path in limbo_paths:
+                try:
+                    osutils.delete_any(path)
+                except OSError as e:
+                    if e.errno != errno.ENOENT:
+                        raise
+                    # XXX: warn? perhaps we just got interrupted at an
+                    # inconvenient moment, but perhaps files are disappearing
+                    # from under us?
+            try:
+                osutils.delete_any(self._limbodir)
+            except OSError:
+                # We don't especially care *why* the dir is immortal.
+                raise ImmortalLimbo(self._limbodir)
+            try:
+                if self._deletiondir is not None:
+                    osutils.delete_any(self._deletiondir)
+            except OSError:
+                raise errors.ImmortalPendingDeletion(self._deletiondir)
+        finally:
+            TreeTransformBase.finalize(self)
+
+    def _limbo_supports_executable(self):
+        """Check if the limbo path supports the executable bit."""
+        return osutils.supports_executable(self._limbodir)
+
+    def _limbo_name(self, trans_id):
+        """Generate the limbo name of a file"""
+        limbo_name = self._limbo_files.get(trans_id)
+        if limbo_name is None:
+            limbo_name = self._generate_limbo_path(trans_id)
+            self._limbo_files[trans_id] = limbo_name
+        return limbo_name
+
+    def _generate_limbo_path(self, trans_id):
+        """Generate a limbo path using the trans_id as the relative path.
+
+        This is suitable as a fallback, and when the transform should not be
+        sensitive to the path encoding of the limbo directory.
+        """
+        self._needs_rename.add(trans_id)
+        return osutils.pathjoin(self._limbodir, trans_id)
+
+    def adjust_path(self, name, parent, trans_id):
+        previous_parent = self._new_parent.get(trans_id)
+        previous_name = self._new_name.get(trans_id)
+        super(DiskTreeTransform, self).adjust_path(name, parent, trans_id)
+        if (trans_id in self._limbo_files
+                and trans_id not in self._needs_rename):
+            self._rename_in_limbo([trans_id])
+            if previous_parent != parent:
+                self._limbo_children[previous_parent].remove(trans_id)
+            if previous_parent != parent or previous_name != name:
+                del self._limbo_children_names[previous_parent][previous_name]
+
+    def _rename_in_limbo(self, trans_ids):
+        """Fix limbo names so that the right final path is produced.
+
+        This means we outsmarted ourselves-- we tried to avoid renaming
+        these files later by creating them with their final names in their
+        final parents.  But now the previous name or parent is no longer
+        suitable, so we have to rename them.
+
+        Even for trans_ids that have no new contents, we must remove their
+        entries from _limbo_files, because they are now stale.
+        """
+        for trans_id in trans_ids:
+            old_path = self._limbo_files[trans_id]
+            self._possibly_stale_limbo_files.add(old_path)
+            del self._limbo_files[trans_id]
+            if trans_id not in self._new_contents:
+                continue
+            new_path = self._limbo_name(trans_id)
+            os.rename(old_path, new_path)
+            self._possibly_stale_limbo_files.remove(old_path)
+            for descendant in self._limbo_descendants(trans_id):
+                desc_path = self._limbo_files[descendant]
+                desc_path = new_path + desc_path[len(old_path):]
+                self._limbo_files[descendant] = desc_path
+
+    def _limbo_descendants(self, trans_id):
+        """Return the set of trans_ids whose limbo paths descend from this."""
+        descendants = set(self._limbo_children.get(trans_id, []))
+        for descendant in list(descendants):
+            descendants.update(self._limbo_descendants(descendant))
+        return descendants
+
+    def _set_mode(self, trans_id, mode_id, typefunc):
+        raise NotImplementedError(self._set_mode)
+
+    def create_file(self, contents, trans_id, mode_id=None, sha1=None):
+        """Schedule creation of a new file.
+
+        :seealso: new_file.
+
+        :param contents: an iterator of strings, all of which will be written
+            to the target destination.
+        :param trans_id: TreeTransform handle
+        :param mode_id: If not None, force the mode of the target file to match
+            the mode of the object referenced by mode_id.
+            Otherwise, we will try to preserve mode bits of an existing file.
+        :param sha1: If the sha1 of this content is already known, pass it in.
+            We can use it to prevent future sha1 computations.
+        """
+        name = self._limbo_name(trans_id)
+        with open(name, 'wb') as f:
+            unique_add(self._new_contents, trans_id, 'file')
+            f.writelines(contents)
+        self._set_mtime(name)
+        self._set_mode(trans_id, mode_id, S_ISREG)
+        # It is unfortunate we have to use lstat instead of fstat, but we just
+        # used utime and chmod on the file, so we need the accurate final
+        # details.
+        if sha1 is not None:
+            self._observed_sha1s[trans_id] = (sha1, osutils.lstat(name))
+
+    def _read_symlink_target(self, trans_id):
+        return os.readlink(self._limbo_name(trans_id))
+
+    def _set_mtime(self, path):
+        """All files that are created get the same mtime.
+
+        This time is set by the first object to be created.
+        """
+        if self._creation_mtime is None:
+            self._creation_mtime = time.time()
+        os.utime(path, (self._creation_mtime, self._creation_mtime))
+
+    def create_hardlink(self, path, trans_id):
+        """Schedule creation of a hard link"""
+        name = self._limbo_name(trans_id)
+        try:
+            os.link(path, name)
+        except OSError as e:
+            if e.errno != errno.EPERM:
+                raise
+            raise errors.HardLinkNotSupported(path)
+        try:
+            unique_add(self._new_contents, trans_id, 'file')
+        except BaseException:
+            # Clean up the file, it never got registered so
+            # TreeTransform.finalize() won't clean it up.
+            os.unlink(name)
+            raise
+
+    def create_directory(self, trans_id):
+        """Schedule creation of a new directory.
+
+        See also new_directory.
+        """
+        os.mkdir(self._limbo_name(trans_id))
+        unique_add(self._new_contents, trans_id, 'directory')
+
+    def create_symlink(self, target, trans_id):
+        """Schedule creation of a new symbolic link.
+
+        target is a bytestring.
+        See also new_symlink.
+        """
+        if self._create_symlinks:
+            os.symlink(target, self._limbo_name(trans_id))
+        else:
+            try:
+                path = FinalPaths(self).get_path(trans_id)
+            except KeyError:
+                path = None
+            trace.warning(
+                'Unable to create symlink "%s" on this filesystem.' % (path,))
+        # 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
+        unique_add(self._new_contents, trans_id, 'symlink')
+
+    def cancel_creation(self, trans_id):
+        """Cancel the creation of new file contents."""
+        del self._new_contents[trans_id]
+        if trans_id in self._observed_sha1s:
+            del self._observed_sha1s[trans_id]
+        children = self._limbo_children.get(trans_id)
+        # if this is a limbo directory with children, move them before removing
+        # the directory
+        if children is not None:
+            self._rename_in_limbo(children)
+            del self._limbo_children[trans_id]
+            del self._limbo_children_names[trans_id]
+        osutils.delete_any(self._limbo_name(trans_id))
+
+    def new_orphan(self, trans_id, parent_id):
+        conf = self._tree.get_config_stack()
+        handle_orphan = conf.get('transform.orphan_policy')
+        handle_orphan(self, trans_id, parent_id)
+
+
 class InventoryTreeTransform(DiskTreeTransform):
     """Represent a tree transformation.
 

=== modified file 'breezy/git/transform.py'
--- breezy/git/transform.py	2020-07-05 19:02:14 +0000
+++ breezy/git/transform.py	2020-07-06 02:29:08 +0000
@@ -19,25 +19,1217 @@
 
 import errno
 import os
+from stat import S_ISREG
+import time
 
-from .. import errors, osutils, ui, urlutils
+from .. import errors, multiparent, osutils, trace, ui, urlutils
 from ..i18n import gettext
 from ..mutabletree import MutableTree
-from ..sixish import viewitems
+from ..sixish import viewitems, viewvalues
 from ..transform import (
-    DiskTreeTransform,
+    TreeTransform,
     _TransformResults,
     _FileMover,
     FinalPaths,
     joinpath,
     unique_add,
     TransformRenameFailed,
+    ImmortalLimbo,
+    ROOT_PARENT,
+    ReusingTransform,
+    MalformedTransform,
     )
 
 from ..bzr import inventory
 from ..bzr.transform import TransformPreview as GitTransformPreview
 
 
+class TreeTransformBase(TreeTransform):
+    """The base class for TreeTransform and its kin."""
+
+    def __init__(self, tree, pb=None, case_sensitive=True):
+        """Constructor.
+
+        :param tree: The tree that will be transformed, but not necessarily
+            the output tree.
+        :param pb: ignored
+        :param case_sensitive: If True, the target of the transform is
+            case sensitive, not just case preserving.
+        """
+        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 = {}
+        # 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
+        # Whether the target is case sensitive
+        self._case_sensitive_target = case_sensitive
+
+    def finalize(self):
+        """Release the working tree lock, if held.
+
+        This is required if apply has not been invoked, but can be invoked
+        even after apply.
+        """
+        if self._tree is None:
+            return
+        for hook in MutableTree.hooks['post_transform']:
+            hook(self._tree, self)
+        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()
+        unique_add(self._new_name, trans_id, name)
+        unique_add(self._new_parent, trans_id, parent)
+        return trans_id
+
+    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
+
+        Instead of creating a root directory, or moving an existing directory,
+        all the attributes and children of the new root are applied to the
+        existing root directory.
+
+        This means that the old root trans-id becomes obsolete, so it is
+        recommended only to invoke this after the root trans-id has become
+        irrelevant.
+
+        """
+        new_roots = [k for k, v in viewitems(self._new_parent)
+                     if v == ROOT_PARENT]
+        if len(new_roots) < 1:
+            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:
+            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
+        # use directly-- some tree children have new parents
+        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)
+
+        # Ensure old_new_root has no directory.
+        if old_new_root in self._new_contents:
+            self.cancel_creation(old_new_root)
+        else:
+            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)
+
+        # destroy path info for old_new_root.
+        del self._new_parent[old_new_root]
+        del self._new_name[old_new_root]
+
+    def trans_id_file_id(self, file_id):
+        """Determine or set the transaction id associated with a file ID.
+        A new id is only created for file_ids that were never present.  If
+        a transaction has been unversioned, it is deliberately still returned.
+        (this will likely lead to an unversioned parent conflict.)
+        """
+        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)
+
+    def version_file(self, trans_id, file_id=None):
+        """Schedule a file to become versioned."""
+        raise NotImplementedError(self.version_file)
+
+    def cancel_versioning(self, trans_id):
+        """Undo a previous versioning of a file"""
+        raise NotImplementedError(self.cancel_versioning)
+
+    def new_paths(self, filesystem_only=False):
+        """Determine the paths of all new and changed files.
+
+        :param filesystem_only: if True, only calculate values for files
+            that require renames or execute bit changes.
+        """
+        new_ids = set()
+        if filesystem_only:
+            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)
+            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)
+        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
+
+    def find_conflicts(self):
+        """Find any violations of inventory or filesystem invariants"""
+        if self._done is True:
+            raise ReusingTransform()
+        conflicts = []
+        # ensure all children of all existent parents are known
+        # all children of non-existent parents are known, by definition.
+        self._add_tree_children()
+        by_parent = self.by_parent()
+        conflicts.extend(self._unversioned_parents(by_parent))
+        conflicts.extend(self._parent_loops())
+        conflicts.extend(self._duplicate_entries(by_parent))
+        conflicts.extend(self._parent_type_conflicts(by_parent))
+        conflicts.extend(self._improper_versioning())
+        conflicts.extend(self._executability_conflicts())
+        conflicts.extend(self._overwrite_conflicts())
+        return conflicts
+
+    def _check_malformed(self):
+        conflicts = self.find_conflicts()
+        if len(conflicts) != 0:
+            raise MalformedTransform(conflicts=conflicts)
+
+    def _add_tree_children(self):
+        """Add all the children of all active parents to the known paths.
+
+        Active parents are those which gain children, and those which are
+        removed.  This is a necessary first step in detecting conflicts.
+        """
+        parents = list(self.by_parent())
+        parents.extend([t for t in self._removed_contents if
+                        self.tree_kind(t) == 'directory'])
+        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)
+            elif self.tree_kind(trans_id) == 'directory':
+                parents.append(trans_id)
+
+        for parent_id in parents:
+            # ensure that all children are registered with the transaction
+            list(self.iter_tree_children(parent_id))
+
+    def _has_named_child(self, name, parent_id, known_children):
+        """Does a parent already have a name child.
+
+        :param name: The searched for name.
+
+        :param parent_id: The parent for which the check is made.
+
+        :param known_children: The already known children. This should have
+            been recently obtained from `self.by_parent.get(parent_id)`
+            (or will be if None is passed).
+        """
+        if known_children is None:
+            known_children = self.by_parent().get(parent_id, [])
+        for child in known_children:
+            if self.final_name(child) == name:
+                return True
+        parent_path = self._tree_id_paths.get(parent_id, None)
+        if parent_path is None:
+            # No parent... no children
+            return False
+        child_path = joinpath(parent_path, name)
+        child_id = self._tree_path_ids.get(child_path, None)
+        if child_id is None:
+            # Not known by the tree transform yet, check the filesystem
+            return osutils.lexists(self._tree.abspath(child_path))
+        else:
+            raise AssertionError('child_id is missing: %s, %s, %s'
+                                 % (name, parent_id, child_id))
+
+    def _available_backup_name(self, name, target_id):
+        """Find an available backup name.
+
+        :param name: The basename of the file.
+
+        :param target_id: The directory trans_id where the backup should
+            be placed.
+        """
+        known_children = self.by_parent().get(target_id, [])
+        return osutils.available_backup_name(
+            name,
+            lambda base: self._has_named_child(
+                base, target_id, known_children))
+
+    def _parent_loops(self):
+        """No entry should be its own ancestor"""
+        conflicts = []
+        for trans_id in self._new_parent:
+            seen = set()
+            parent_id = trans_id
+            while parent_id != ROOT_PARENT:
+                seen.add(parent_id)
+                try:
+                    parent_id = self.final_parent(parent_id)
+                except KeyError:
+                    break
+                if parent_id == trans_id:
+                    conflicts.append(('parent loop', trans_id))
+                if parent_id in seen:
+                    break
+        return conflicts
+
+    def _unversioned_parents(self, by_parent):
+        """If parent directories are versioned, children must be versioned."""
+        conflicts = []
+        for parent_id, children in viewitems(by_parent):
+            if parent_id == ROOT_PARENT:
+                continue
+            if self.final_is_versioned(parent_id):
+                continue
+            for child_id in children:
+                if self.final_is_versioned(child_id):
+                    conflicts.append(('unversioned parent', parent_id))
+                    break
+        return conflicts
+
+    def _improper_versioning(self):
+        """Cannot version a file with no contents, or a bad type.
+
+        However, existing entries with no contents are okay.
+        """
+        conflicts = []
+        for trans_id in self._new_id:
+            kind = self.final_kind(trans_id)
+            if kind == 'symlink' and not self._tree.supports_symlinks():
+                # Ignore symlinks as they are not supported on this platform
+                continue
+            if kind is None:
+                conflicts.append(('versioning no contents', trans_id))
+                continue
+            if not self._tree.versionable_kind(kind):
+                conflicts.append(('versioning bad kind', trans_id, kind))
+        return conflicts
+
+    def _executability_conflicts(self):
+        """Check for bad executability changes.
+
+        Only versioned files may have their executability set, because
+        1. only versioned entries can have executability under windows
+        2. only files can be executable.  (The execute bit on a directory
+           does not indicate searchability)
+        """
+        conflicts = []
+        for trans_id in self._new_executability:
+            if not self.final_is_versioned(trans_id):
+                conflicts.append(('unversioned executability', trans_id))
+            else:
+                if self.final_kind(trans_id) != "file":
+                    conflicts.append(('non-file executability', trans_id))
+        return conflicts
+
+    def _overwrite_conflicts(self):
+        """Check for overwrites (not permitted on Win32)"""
+        conflicts = []
+        for trans_id in self._new_contents:
+            if self.tree_kind(trans_id) is None:
+                continue
+            if trans_id not in self._removed_contents:
+                conflicts.append(('overwrite', trans_id,
+                                  self.final_name(trans_id)))
+        return conflicts
+
+    def _duplicate_entries(self, by_parent):
+        """No directory may have two entries with the same name."""
+        conflicts = []
+        if (self._new_name, self._new_parent) == ({}, {}):
+            return conflicts
+        for children in viewvalues(by_parent):
+            name_ids = []
+            for child_tid in children:
+                name = self.final_name(child_tid)
+                if name is not None:
+                    # Keep children only if they still exist in the end
+                    if not self._case_sensitive_target:
+                        name = name.lower()
+                    name_ids.append((name, child_tid))
+            name_ids.sort()
+            last_name = None
+            last_trans_id = None
+            for name, trans_id in name_ids:
+                kind = self.final_kind(trans_id)
+                if kind is None and not self.final_is_versioned(trans_id):
+                    continue
+                if name == last_name:
+                    conflicts.append(('duplicate', last_trans_id, trans_id,
+                                      name))
+                last_name = name
+                last_trans_id = trans_id
+        return conflicts
+
+    def _parent_type_conflicts(self, by_parent):
+        """Children must have a directory parent"""
+        conflicts = []
+        for parent_id, children in viewitems(by_parent):
+            if parent_id == ROOT_PARENT:
+                continue
+            no_children = True
+            for child_id in children:
+                if self.final_kind(child_id) is not None:
+                    no_children = False
+                    break
+            if no_children:
+                continue
+            # There is at least a child, so we need an existing directory to
+            # contain it.
+            kind = self.final_kind(parent_id)
+            if kind is None:
+                # The directory will be deleted
+                conflicts.append(('missing parent', parent_id))
+            elif kind != "directory":
+                # Meh, we need a *directory* to put something in it
+                conflicts.append(('non-directory parent', parent_id))
+        return conflicts
+
+    def _set_executability(self, path, trans_id):
+        """Set the executability of versioned files """
+        if self._tree._supports_executable():
+            new_executability = self._new_executability[trans_id]
+            abspath = self._tree.abspath(path)
+            current_mode = os.stat(abspath).st_mode
+            if new_executability:
+                umask = os.umask(0)
+                os.umask(umask)
+                to_mode = current_mode | (0o100 & ~umask)
+                # Enable x-bit for others only if they can read it.
+                if current_mode & 0o004:
+                    to_mode |= 0o001 & ~umask
+                if current_mode & 0o040:
+                    to_mode |= 0o010 & ~umask
+            else:
+                to_mode = current_mode & ~0o111
+            osutils.chmod_if_possible(abspath, to_mode)
+
+    def _new_entry(self, name, parent_id, file_id):
+        """Helper function to create a new filesystem entry."""
+        trans_id = self.create_path(name, parent_id)
+        if file_id is not None:
+            self.version_file(trans_id, file_id=file_id)
+        return trans_id
+
+    def new_file(self, name, parent_id, contents, file_id=None,
+                 executable=None, sha1=None):
+        """Convenience method to create files.
+
+        name is the name of the file to create.
+        parent_id is the transaction id of the parent directory of the file.
+        contents is an iterator of bytestrings, which will be used to produce
+        the file.
+        :param file_id: The inventory ID of the file, if it is to be versioned.
+        :param executable: Only valid when a file_id has been supplied.
+        """
+        trans_id = self._new_entry(name, parent_id, file_id)
+        # TODO: rather than scheduling a set_executable call,
+        # have create_file create the file with the right mode.
+        self.create_file(contents, trans_id, sha1=sha1)
+        if executable is not None:
+            self.set_executability(executable, trans_id)
+        return trans_id
+
+    def new_directory(self, name, parent_id, file_id=None):
+        """Convenience method to create directories.
+
+        name is the name of the directory to create.
+        parent_id is the transaction id of the parent directory of the
+        directory.
+        file_id is the inventory ID of the directory, if it is to be versioned.
+        """
+        trans_id = self._new_entry(name, parent_id, file_id)
+        self.create_directory(trans_id)
+        return trans_id
+
+    def new_symlink(self, name, parent_id, target, file_id=None):
+        """Convenience method to create symbolic link.
+
+        name is the name of the symlink to create.
+        parent_id is the transaction id of the parent directory of the symlink.
+        target is a bytestring of the target of the symlink.
+        file_id is the inventory ID of the file, if it is to be versioned.
+        """
+        trans_id = self._new_entry(name, parent_id, file_id)
+        self.create_symlink(target, trans_id)
+        return trans_id
+
+    def new_orphan(self, trans_id, parent_id):
+        """Schedule an item to be orphaned.
+
+        When a directory is about to be removed, its children, if they are not
+        versioned are moved out of the way: they don't have a parent anymore.
+
+        :param trans_id: The trans_id of the existing item.
+        :param parent_id: The parent trans_id of the item.
+        """
+        raise NotImplementedError(self.new_orphan)
+
+    def _get_potential_orphans(self, dir_id):
+        """Find the potential orphans in a directory.
+
+        A directory can't be safely deleted if there are versioned files in it.
+        If all the contained files are unversioned then they can be orphaned.
+
+        The 'None' return value means that the directory contains at least one
+        versioned file and should not be deleted.
+
+        :param dir_id: The directory trans id.
+
+        :return: A list of the orphan trans ids or None if at least one
+             versioned file is present.
+        """
+        orphans = []
+        # Find the potential orphans, stop if one item should be kept
+        for child_tid in self.by_parent()[dir_id]:
+            if child_tid in self._removed_contents:
+                # The child is removed as part of the transform. Since it was
+                # versioned before, it's not an orphan
+                continue
+            if not self.final_is_versioned(child_tid):
+                # The child is not versioned
+                orphans.append(child_tid)
+            else:
+                # We have a versioned file here, searching for orphans is
+                # meaningless.
+                orphans = None
+                break
+        return orphans
+
+    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._removed_contents)
+        trans_ids.update(self._new_contents)
+        trans_ids.update(self._new_executability)
+        trans_ids.update(self._new_name)
+        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):
+        """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_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()
+        results = []
+        # Now iterate through all active file_ids
+        for file_id in set(from_trans_ids).union(to_trans_ids):
+            modified = False
+            from_trans_id = from_trans_ids.get(file_id)
+            # find file ids, and determine versioning state
+            if from_trans_id 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:
+                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:
+                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:
+                modified = True
+            elif to_kind in ('file', 'symlink') and (
+                    to_trans_id != from_trans_id
+                    or to_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_executable == to_executable):
+                continue
+            results.append(
+                TreeChange(
+                    file_id, (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)))
+
+        def path_key(c):
+            return (c.path[0] or '', c.path[1] or '')
+        return iter(sorted(results, key=path_key))
+
+    def get_preview_tree(self):
+        """Return a tree representing the result of the transform.
+
+        The tree is a snapshot, and altering the TreeTransform will invalidate
+        it.
+        """
+        raise NotImplementedError(self.get_preview_tree)
+
+    def commit(self, branch, message, merge_parents=None, strict=False,
+               timestamp=None, timezone=None, committer=None, authors=None,
+               revprops=None, revision_id=None):
+        """Commit the result of this TreeTransform to a branch.
+
+        :param branch: The branch to commit to.
+        :param message: The message to attach to the commit.
+        :param merge_parents: Additional parent revision-ids specified by
+            pending merges.
+        :param strict: If True, abort the commit if there are unversioned
+            files.
+        :param timestamp: if not None, seconds-since-epoch for the time and
+            date.  (May be a float.)
+        :param timezone: Optional timezone for timestamp, as an offset in
+            seconds.
+        :param committer: Optional committer in email-id format.
+            (e.g. "J Random Hacker <[e-mail]>")
+        :param authors: Optional list of authors in email-id format.
+        :param revprops: Optional dictionary of revision properties.
+        :param revision_id: Optional revision id.  (Specifying a revision-id
+            may reduce performance for some non-native formats.)
+        :return: The revision_id of the revision committed.
+        """
+        self._check_malformed()
+        if strict:
+            unversioned = set(self._new_contents).difference(set(self._new_id))
+            for trans_id in unversioned:
+                if not self.final_is_versioned(trans_id):
+                    raise errors.StrictCommitFailed()
+
+        revno, last_rev_id = branch.last_revision_info()
+        if last_rev_id == _mod_revision.NULL_REVISION:
+            if merge_parents is not None:
+                raise ValueError('Cannot supply merge parents for first'
+                                 ' commit.')
+            parent_ids = []
+        else:
+            parent_ids = [last_rev_id]
+            if merge_parents is not None:
+                parent_ids.extend(merge_parents)
+        if self._tree.get_revision_id() != last_rev_id:
+            raise ValueError('TreeTransform not based on branch basis: %s' %
+                             self._tree.get_revision_id().decode('utf-8'))
+        from .. import commit
+        revprops = commit.Commit.update_revprops(revprops, branch, authors)
+        builder = branch.get_commit_builder(parent_ids,
+                                            timestamp=timestamp,
+                                            timezone=timezone,
+                                            committer=committer,
+                                            revprops=revprops,
+                                            revision_id=revision_id)
+        preview = self.get_preview_tree()
+        list(builder.record_iter_changes(preview, last_rev_id,
+                                         self.iter_changes()))
+        builder.finish_inventory()
+        revision_id = builder.commit(message)
+        branch.set_last_revision_info(revno + 1, revision_id)
+        return revision_id
+
+    def _text_parent(self, trans_id):
+        path = self.tree_path(trans_id)
+        try:
+            if path is None or self._tree.kind(path) != 'file':
+                return None
+        except errors.NoSuchFile:
+            return None
+        return path
+
+    def _get_parents_texts(self, trans_id):
+        """Get texts for compression parents of this file."""
+        path = self._text_parent(trans_id)
+        if path is None:
+            return ()
+        return (self._tree.get_file_text(path),)
+
+    def _get_parents_lines(self, trans_id):
+        """Get lines for compression parents of this file."""
+        path = self._text_parent(trans_id)
+        if path is None:
+            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.
+
+        :seealso: new_file.
+
+        :param contents: an iterator of strings, all of which will be written
+            to the target destination.
+        :param trans_id: TreeTransform handle
+        :param mode_id: If not None, force the mode of the target file to match
+            the mode of the object referenced by mode_id.
+            Otherwise, we will try to preserve mode bits of an existing file.
+        :param sha1: If the sha1 of this content is already known, pass it in.
+            We can use it to prevent future sha1 computations.
+        """
+        raise NotImplementedError(self.create_file)
+
+    def create_directory(self, trans_id):
+        """Schedule creation of a new directory.
+
+        See also new_directory.
+        """
+        raise NotImplementedError(self.create_directory)
+
+    def create_symlink(self, target, trans_id):
+        """Schedule creation of a new symbolic link.
+
+        target is a bytestring.
+        See also new_symlink.
+        """
+        raise NotImplementedError(self.create_symlink)
+
+    def create_hardlink(self, path, trans_id):
+        """Schedule creation of a hard link"""
+        raise NotImplementedError(self.create_hardlink)
+
+    def cancel_creation(self, trans_id):
+        """Cancel the creation of new file contents."""
+        raise NotImplementedError(self.cancel_creation)
+
+    def apply(self, no_conflicts=False, precomputed_delta=None, _mover=None):
+        """Apply all changes to the inventory and filesystem.
+
+        If filesystem or inventory conflicts are present, MalformedTransform
+        will be thrown.
+
+        If apply succeeds, finalize is not necessary.
+
+        :param no_conflicts: if True, the caller guarantees there are no
+            conflicts, so no check is made.
+        :param precomputed_delta: An inventory delta to use instead of
+            calculating one.
+        :param _mover: Supply an alternate FileMover, for testing
+        """
+        raise NotImplementedError(self.apply)
+
+
+class DiskTreeTransform(TreeTransformBase):
+    """Tree transform storing its contents on disk."""
+
+    def __init__(self, tree, limbodir, pb=None, case_sensitive=True):
+        """Constructor.
+        :param tree: The tree that will be transformed, but not necessarily
+            the output tree.
+        :param limbodir: A directory where new files can be stored until
+            they are installed in their proper places
+        :param pb: ignored
+        :param case_sensitive: If True, the target of the transform is
+            case sensitive, not just case preserving.
+        """
+        TreeTransformBase.__init__(self, tree, pb, case_sensitive)
+        self._limbodir = limbodir
+        self._deletiondir = None
+        # A mapping of transform ids to their limbo filename
+        self._limbo_files = {}
+        self._possibly_stale_limbo_files = set()
+        # A mapping of transform ids to a set of the transform ids of children
+        # that their limbo directory has
+        self._limbo_children = {}
+        # Map transform ids to maps of child filename to child transform id
+        self._limbo_children_names = {}
+        # List of transform ids that need to be renamed from limbo into place
+        self._needs_rename = set()
+        self._creation_mtime = None
+        self._create_symlinks = osutils.supports_symlinks(self._limbodir)
+
+    def finalize(self):
+        """Release the working tree lock, if held, clean up limbo dir.
+
+        This is required if apply has not been invoked, but can be invoked
+        even after apply.
+        """
+        if self._tree is None:
+            return
+        try:
+            limbo_paths = list(viewvalues(self._limbo_files))
+            limbo_paths.extend(self._possibly_stale_limbo_files)
+            limbo_paths.sort(reverse=True)
+            for path in limbo_paths:
+                try:
+                    osutils.delete_any(path)
+                except OSError as e:
+                    if e.errno != errno.ENOENT:
+                        raise
+                    # XXX: warn? perhaps we just got interrupted at an
+                    # inconvenient moment, but perhaps files are disappearing
+                    # from under us?
+            try:
+                osutils.delete_any(self._limbodir)
+            except OSError:
+                # We don't especially care *why* the dir is immortal.
+                raise ImmortalLimbo(self._limbodir)
+            try:
+                if self._deletiondir is not None:
+                    osutils.delete_any(self._deletiondir)
+            except OSError:
+                raise errors.ImmortalPendingDeletion(self._deletiondir)
+        finally:
+            TreeTransformBase.finalize(self)
+
+    def _limbo_supports_executable(self):
+        """Check if the limbo path supports the executable bit."""
+        return osutils.supports_executable(self._limbodir)
+
+    def _limbo_name(self, trans_id):
+        """Generate the limbo name of a file"""
+        limbo_name = self._limbo_files.get(trans_id)
+        if limbo_name is None:
+            limbo_name = self._generate_limbo_path(trans_id)
+            self._limbo_files[trans_id] = limbo_name
+        return limbo_name
+
+    def _generate_limbo_path(self, trans_id):
+        """Generate a limbo path using the trans_id as the relative path.
+
+        This is suitable as a fallback, and when the transform should not be
+        sensitive to the path encoding of the limbo directory.
+        """
+        self._needs_rename.add(trans_id)
+        return osutils.pathjoin(self._limbodir, trans_id)
+
+    def adjust_path(self, name, parent, trans_id):
+        previous_parent = self._new_parent.get(trans_id)
+        previous_name = self._new_name.get(trans_id)
+        super(DiskTreeTransform, self).adjust_path(name, parent, trans_id)
+        if (trans_id in self._limbo_files
+                and trans_id not in self._needs_rename):
+            self._rename_in_limbo([trans_id])
+            if previous_parent != parent:
+                self._limbo_children[previous_parent].remove(trans_id)
+            if previous_parent != parent or previous_name != name:
+                del self._limbo_children_names[previous_parent][previous_name]
+
+    def _rename_in_limbo(self, trans_ids):
+        """Fix limbo names so that the right final path is produced.
+
+        This means we outsmarted ourselves-- we tried to avoid renaming
+        these files later by creating them with their final names in their
+        final parents.  But now the previous name or parent is no longer
+        suitable, so we have to rename them.
+
+        Even for trans_ids that have no new contents, we must remove their
+        entries from _limbo_files, because they are now stale.
+        """
+        for trans_id in trans_ids:
+            old_path = self._limbo_files[trans_id]
+            self._possibly_stale_limbo_files.add(old_path)
+            del self._limbo_files[trans_id]
+            if trans_id not in self._new_contents:
+                continue
+            new_path = self._limbo_name(trans_id)
+            os.rename(old_path, new_path)
+            self._possibly_stale_limbo_files.remove(old_path)
+            for descendant in self._limbo_descendants(trans_id):
+                desc_path = self._limbo_files[descendant]
+                desc_path = new_path + desc_path[len(old_path):]
+                self._limbo_files[descendant] = desc_path
+
+    def _limbo_descendants(self, trans_id):
+        """Return the set of trans_ids whose limbo paths descend from this."""
+        descendants = set(self._limbo_children.get(trans_id, []))
+        for descendant in list(descendants):
+            descendants.update(self._limbo_descendants(descendant))
+        return descendants
+
+    def _set_mode(self, trans_id, mode_id, typefunc):
+        raise NotImplementedError(self._set_mode)
+
+    def create_file(self, contents, trans_id, mode_id=None, sha1=None):
+        """Schedule creation of a new file.
+
+        :seealso: new_file.
+
+        :param contents: an iterator of strings, all of which will be written
+            to the target destination.
+        :param trans_id: TreeTransform handle
+        :param mode_id: If not None, force the mode of the target file to match
+            the mode of the object referenced by mode_id.
+            Otherwise, we will try to preserve mode bits of an existing file.
+        :param sha1: If the sha1 of this content is already known, pass it in.
+            We can use it to prevent future sha1 computations.
+        """
+        name = self._limbo_name(trans_id)
+        with open(name, 'wb') as f:
+            unique_add(self._new_contents, trans_id, 'file')
+            f.writelines(contents)
+        self._set_mtime(name)
+        self._set_mode(trans_id, mode_id, S_ISREG)
+        # It is unfortunate we have to use lstat instead of fstat, but we just
+        # used utime and chmod on the file, so we need the accurate final
+        # details.
+        if sha1 is not None:
+            self._observed_sha1s[trans_id] = (sha1, osutils.lstat(name))
+
+    def _read_symlink_target(self, trans_id):
+        return os.readlink(self._limbo_name(trans_id))
+
+    def _set_mtime(self, path):
+        """All files that are created get the same mtime.
+
+        This time is set by the first object to be created.
+        """
+        if self._creation_mtime is None:
+            self._creation_mtime = time.time()
+        os.utime(path, (self._creation_mtime, self._creation_mtime))
+
+    def create_hardlink(self, path, trans_id):
+        """Schedule creation of a hard link"""
+        name = self._limbo_name(trans_id)
+        try:
+            os.link(path, name)
+        except OSError as e:
+            if e.errno != errno.EPERM:
+                raise
+            raise errors.HardLinkNotSupported(path)
+        try:
+            unique_add(self._new_contents, trans_id, 'file')
+        except BaseException:
+            # Clean up the file, it never got registered so
+            # TreeTransform.finalize() won't clean it up.
+            os.unlink(name)
+            raise
+
+    def create_directory(self, trans_id):
+        """Schedule creation of a new directory.
+
+        See also new_directory.
+        """
+        os.mkdir(self._limbo_name(trans_id))
+        unique_add(self._new_contents, trans_id, 'directory')
+
+    def create_symlink(self, target, trans_id):
+        """Schedule creation of a new symbolic link.
+
+        target is a bytestring.
+        See also new_symlink.
+        """
+        if self._create_symlinks:
+            os.symlink(target, self._limbo_name(trans_id))
+        else:
+            try:
+                path = FinalPaths(self).get_path(trans_id)
+            except KeyError:
+                path = None
+            trace.warning(
+                'Unable to create symlink "%s" on this filesystem.' % (path,))
+        # 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
+        unique_add(self._new_contents, trans_id, 'symlink')
+
+    def cancel_creation(self, trans_id):
+        """Cancel the creation of new file contents."""
+        del self._new_contents[trans_id]
+        if trans_id in self._observed_sha1s:
+            del self._observed_sha1s[trans_id]
+        children = self._limbo_children.get(trans_id)
+        # if this is a limbo directory with children, move them before removing
+        # the directory
+        if children is not None:
+            self._rename_in_limbo(children)
+            del self._limbo_children[trans_id]
+            del self._limbo_children_names[trans_id]
+        osutils.delete_any(self._limbo_name(trans_id))
+
+    def new_orphan(self, trans_id, parent_id):
+        conf = self._tree.get_config_stack()
+        handle_orphan = conf.get('transform.orphan_policy')
+        handle_orphan(self, trans_id, parent_id)
+
+
 class GitTreeTransform(DiskTreeTransform):
     """Represent a tree transformation.
 

=== modified file 'breezy/git/tree.py'
--- breezy/git/tree.py	2020-07-05 13:18:03 +0000
+++ breezy/git/tree.py	2020-07-06 02:29:08 +0000
@@ -1639,7 +1639,7 @@
         return GitTreeTransform(self, pb=pb)
 
     def preview_transform(self, pb=None):
-        from ..transform import GitTransformPreview
+        from .transform import GitTransformPreview
         return GitTransformPreview(self, pb=pb)
 
 

=== modified file 'breezy/tests/per_tree/test_transform.py'
--- breezy/tests/per_tree/test_transform.py	2020-07-05 00:03:01 +0000
+++ breezy/tests/per_tree/test_transform.py	2020-07-06 02:29:08 +0000
@@ -19,6 +19,7 @@
 
 from ... import (
     revision as _mod_revision,
+    tests,
     trace,
     )
 from ...diff import show_diff_trees
@@ -43,13 +44,6 @@
 
 
 
-A_ENTRY = (b'a-id', ('a', 'a'), True, (True, True),
-           (b'TREE_ROOT', b'TREE_ROOT'), ('a', 'a'), ('file', 'file'),
-           (False, False), False)
-ROOT_ENTRY = (b'TREE_ROOT', ('', ''), False, (True, True), (None, None),
-              ('', ''), ('directory', 'directory'), (False, False), False)
-
-
 class TestTransformPreview(TestCaseWithTree):
 
     def setUp(self):
@@ -60,8 +54,7 @@
     def create_tree(self):
         tree = self.make_branch_and_tree('.')
         self.build_tree_contents([('a', b'content 1')])
-        tree.set_root_id(b'TREE_ROOT')
-        tree.add('a', b'a-id')
+        tree.add('a')
         revid1 = tree.commit('rev1')
         return tree.branch.repository.revision_tree(revid1)
 
@@ -110,10 +103,9 @@
         self.requireFeature(SymlinkFeature)
         tree = self.make_branch_and_tree('.')
         self.build_tree_contents([('a', 'content 1')])
-        tree.set_root_id(b'TREE_ROOT')
         tree.add('a')
         os.symlink('a', 'foo')
-        tree.add('foo', b'foo-id')
+        tree.add('foo')
         revid1 = tree.commit('rev1')
         revision_tree = tree.branch.repository.revision_tree(revid1)
         preview = revision_tree.preview_transform()
@@ -140,14 +132,14 @@
         self.addCleanup(preview.finalize)
         preview.new_file('a', preview.root, [b'content 2'])
         resolve_conflicts(preview)
-        trans_id = preview.trans_id_file_id(b'a-id')
+        trans_id = preview.trans_id_tree_path('a')
         self.assertEqual('a.moved', preview.final_name(trans_id))
 
     def get_tree_and_preview_tree(self):
         revision_tree = self.create_tree()
         preview = revision_tree.preview_transform()
         self.addCleanup(preview.finalize)
-        a_trans_id = preview.trans_id_file_id(b'a-id')
+        a_trans_id = preview.trans_id_tree_path('a')
         preview.delete_contents(a_trans_id)
         preview.create_file([b'b content'], a_trans_id)
         preview_tree = preview.get_preview_tree()
@@ -156,7 +148,7 @@
     def test_iter_changes(self):
         revision_tree, preview_tree = self.get_tree_and_preview_tree()
         root = revision_tree.path2id('')
-        self.assertEqual([(b'a-id', ('a', 'a'), True, (True, True),
+        self.assertEqual([(revision_tree.path2id('a'), ('a', 'a'), True, (True, True),
                            (root, root), ('a', 'a'), ('file', 'file'),
                            (False, False), False)],
                          list(preview_tree.iter_changes(revision_tree)))
@@ -165,19 +157,39 @@
         revision_tree, preview_tree = self.get_tree_and_preview_tree()
         changes = preview_tree.iter_changes(revision_tree,
                                             include_unchanged=True)
-        self.assertEqual([ROOT_ENTRY, A_ENTRY], list(changes))
+
+        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)
+
+ 
+        self.assertEqual([root_entry, a_entry], list(changes))
 
     def test_specific_files(self):
         revision_tree, preview_tree = self.get_tree_and_preview_tree()
         changes = preview_tree.iter_changes(revision_tree,
                                             specific_files=[''])
-        self.assertEqual([A_ENTRY], list(changes))
+        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)
+
+ 
+        self.assertEqual([a_entry], list(changes))
 
     def test_want_unversioned(self):
         revision_tree, preview_tree = self.get_tree_and_preview_tree()
         changes = preview_tree.iter_changes(revision_tree,
                                             want_unversioned=True)
-        self.assertEqual([A_ENTRY], list(changes))
+        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)
+
+        self.assertEqual([a_entry], list(changes))
 
     def test_ignore_extra_trees_no_specific_files(self):
         # extra_trees is harmless without specific_files, so we'll silently
@@ -217,7 +229,7 @@
     def test_get_file_mtime_renamed(self):
         work_tree = self.make_branch_and_tree('tree')
         self.build_tree(['tree/file'])
-        work_tree.add('file', b'file-id')
+        work_tree.add('file')
         preview = work_tree.preview_transform()
         self.addCleanup(preview.finalize)
         file_trans_id = preview.trans_id_tree_path('file')
@@ -229,7 +241,7 @@
     def test_get_file_size(self):
         work_tree = self.make_branch_and_tree('tree')
         self.build_tree_contents([('tree/old', b'old')])
-        work_tree.add('old', b'old-id')
+        work_tree.add('old')
         preview = work_tree.preview_transform()
         self.addCleanup(preview.finalize)
         preview.new_file('name', preview.root, [b'contents'], b'new-id',
@@ -254,6 +266,9 @@
                          preview_tree.get_symlink_target('symlink'))
 
     def test_all_file_ids(self):
+        if not self.workingtree_format.supports_setting_file_ids:
+            raise tests.TestNotApplicable(
+                'format does not support setting file ids')
         tree = self.make_branch_and_tree('tree')
         self.build_tree(['tree/a', 'tree/b', 'tree/c'])
         tree.add(['a', 'b', 'c'], [b'a-id', b'b-id', b'c-id'])
@@ -294,30 +309,40 @@
     def test_path2id_moved(self):
         tree = self.make_branch_and_tree('tree')
         self.build_tree(['tree/old_parent/', 'tree/old_parent/child'])
-        tree.add(['old_parent', 'old_parent/child'],
-                 [b'old_parent-id', b'child-id'])
+        tree.add(['old_parent', 'old_parent/child'])
         preview = tree.preview_transform()
         self.addCleanup(preview.finalize)
         new_parent = preview.new_directory('new_parent', preview.root,
                                            b'new_parent-id')
         preview.adjust_path('child', new_parent,
-                            preview.trans_id_file_id(b'child-id'))
+                            preview.trans_id_tree_path('old_parent/child'))
         preview_tree = preview.get_preview_tree()
         self.assertFalse(preview_tree.is_versioned('old_parent/child'))
-        self.assertEqual(b'child-id', preview_tree.path2id('new_parent/child'))
+        self.assertEqual(
+            'new_parent/child',
+            find_previous_path(tree, preview_tree, 'old_parent/child'))
+        if self.workingtree_format.supports_setting_file_ids:
+            self.assertEqual(
+                tree.path2id('old_parent/child'),
+                preview_tree.path2id('new_parent/child'))
 
     def test_path2id_renamed_parent(self):
         tree = self.make_branch_and_tree('tree')
         self.build_tree(['tree/old_name/', 'tree/old_name/child'])
-        tree.add(['old_name', 'old_name/child'],
-                 [b'parent-id', b'child-id'])
+        tree.add(['old_name', 'old_name/child'])
         preview = tree.preview_transform()
         self.addCleanup(preview.finalize)
         preview.adjust_path('new_name', preview.root,
-                            preview.trans_id_file_id(b'parent-id'))
+                            preview.trans_id_tree_path('old_name'))
         preview_tree = preview.get_preview_tree()
         self.assertFalse(preview_tree.is_versioned('old_name/child'))
-        self.assertEqual(b'child-id', preview_tree.path2id('new_name/child'))
+        self.assertEqual(
+            'new_name/child',
+            find_previous_path(tree, preview_tree, 'old_name/child'))
+        if tree.supports_setting_file_ids:
+            self.assertEqual(
+                tree.path2id('old_name/child'),
+                preview_tree.path2id('new_name/child'))
 
     def assertMatchingIterEntries(self, tt, specific_files=None):
         preview_tree = tt.get_preview_tree()
@@ -338,33 +363,33 @@
     def test_iter_entries_by_dir_deleted(self):
         tree = self.make_branch_and_tree('tree')
         self.build_tree(['tree/deleted'])
-        tree.add('deleted', b'deleted-id')
+        tree.add('deleted')
         tt = tree.transform()
-        tt.delete_contents(tt.trans_id_file_id(b'deleted-id'))
+        tt.delete_contents(tt.trans_id_tree_path('deleted'))
         self.assertMatchingIterEntries(tt)
 
     def test_iter_entries_by_dir_unversioned(self):
         tree = self.make_branch_and_tree('tree')
         self.build_tree(['tree/removed'])
-        tree.add('removed', b'removed-id')
+        tree.add('removed')
         tt = tree.transform()
-        tt.unversion_file(tt.trans_id_file_id(b'removed-id'))
+        tt.unversion_file(tt.trans_id_tree_path('removed'))
         self.assertMatchingIterEntries(tt)
 
     def test_iter_entries_by_dir_moved(self):
         tree = self.make_branch_and_tree('tree')
         self.build_tree(['tree/moved', 'tree/new_parent/'])
-        tree.add(['moved', 'new_parent'], [b'moved-id', b'new_parent-id'])
+        tree.add(['moved', 'new_parent'])
         tt = tree.transform()
-        tt.adjust_path('moved', tt.trans_id_file_id(b'new_parent-id'),
-                       tt.trans_id_file_id(b'moved-id'))
+        tt.adjust_path(
+            'moved', tt.trans_id_tree_path('new_parent'),
+            tt.trans_id_tree_path('moved'))
         self.assertMatchingIterEntries(tt)
 
     def test_iter_entries_by_dir_specific_files(self):
         tree = self.make_branch_and_tree('tree')
-        tree.set_root_id(b'tree-root-id')
         self.build_tree(['tree/parent/', 'tree/parent/child'])
-        tree.add(['parent', 'parent/child'], [b'parent-id', b'child-id'])
+        tree.add(['parent', 'parent/child'])
         tt = tree.transform()
         self.assertMatchingIterEntries(tt, ['', 'parent/child'])
 
@@ -446,12 +471,12 @@
     def test_annotate(self):
         tree = self.make_branch_and_tree('tree')
         self.build_tree_contents([('tree/file', b'a\n')])
-        tree.add('file', b'file-id')
+        tree.add('file')
         revid1 = tree.commit('a')
         self.build_tree_contents([('tree/file', b'a\nb\n')])
         preview = tree.preview_transform()
         self.addCleanup(preview.finalize)
-        file_trans_id = preview.trans_id_file_id(b'file-id')
+        file_trans_id = preview.trans_id_tree_path('file')
         preview.delete_contents(file_trans_id)
         preview.create_file([b'a\nb\nc\n'], file_trans_id)
         preview_tree = preview.get_preview_tree()
@@ -636,12 +661,14 @@
 
     def test_merge_preview_into_workingtree(self):
         tree = self.make_branch_and_tree('tree')
-        tree.set_root_id(b'TREE_ROOT')
+        if tree.supports_setting_file_ids():
+            tree.set_root_id(b'TREE_ROOT')
         tt = tree.preview_transform()
         self.addCleanup(tt.finalize)
         tt.new_file('name', tt.root, [b'content'], b'file-id')
         tree2 = self.make_branch_and_tree('tree2')
-        tree2.set_root_id(b'TREE_ROOT')
+        if tree.supports_setting_file_ids():
+            tree2.set_root_id(b'TREE_ROOT')
         merger = Merger.from_uncommitted(tree2, tt.get_preview_tree(),
                                          tree.basis_tree())
         merger.merge_type = Merge3Merger
@@ -650,11 +677,11 @@
     def test_merge_preview_into_workingtree_handles_conflicts(self):
         tree = self.make_branch_and_tree('tree')
         self.build_tree_contents([('tree/foo', b'bar')])
-        tree.add('foo', b'foo-id')
+        tree.add('foo')
         tree.commit('foo')
         tt = tree.preview_transform()
         self.addCleanup(tt.finalize)
-        trans_id = tt.trans_id_file_id(b'foo-id')
+        trans_id = tt.trans_id_tree_path('foo')
         tt.delete_contents(trans_id)
         tt.create_file([b'baz'], trans_id)
         tree2 = tree.controldir.sprout('tree2').open_workingtree()
@@ -682,7 +709,7 @@
         self.assertTrue(tree.has_filename('new'))
         self.assertTrue(tree.has_filename('modified'))
 
-    def test_is_executable(self):
+    def test_is_executable2(self):
         tree = self.make_branch_and_tree('tree')
         preview = tree.preview_transform()
         self.addCleanup(preview.finalize)

=== modified file 'breezy/tests/per_workingtree/test_transform.py'
--- breezy/tests/per_workingtree/test_transform.py	2020-07-05 17:49:39 +0000
+++ breezy/tests/per_workingtree/test_transform.py	2020-07-06 02:29:08 +0000
@@ -256,6 +256,9 @@
         self.assertEqual(st1.st_mtime, st2.st_mtime)
 
     def test_change_root_id(self):
+        if not self.workingtree_format.supports_setting_file_ids:
+            raise tests.TestNotApplicable(
+                'format does not support setting file ids')
         transform, root = self.transform()
         self.assertNotEqual(b'new-root-id', self.wt.path2id(''))
         transform.new_directory('', ROOT_PARENT, b'new-root-id')
@@ -265,7 +268,18 @@
         transform.apply()
         self.assertEqual(b'new-root-id', self.wt.path2id(''))
 
+    def test_replace_root(self):
+        transform, root = self.transform()
+        transform.new_directory('', ROOT_PARENT, b'new-root-id')
+        transform.delete_contents(root)
+        transform.unversion_file(root)
+        transform.fixup_new_roots()
+        transform.apply()
+
     def test_change_root_id_add_files(self):
+        if not self.workingtree_format.supports_setting_file_ids:
+            raise tests.TestNotApplicable(
+                'format does not support setting file ids')
         transform, root = self.transform()
         self.assertNotEqual(b'new-root-id', self.wt.path2id(''))
         new_trans_id = transform.new_directory('', ROOT_PARENT, b'new-root-id')

=== modified file 'breezy/transform.py'
--- breezy/transform.py	2020-07-05 19:02:14 +0000
+++ breezy/transform.py	2020-07-06 02:29:08 +0000
@@ -531,1192 +531,6 @@
         raise NotImplementedError(self.cancel_creation)
 
 
-class TreeTransformBase(TreeTransform):
-    """The base class for TreeTransform and its kin."""
-
-    def __init__(self, tree, pb=None, case_sensitive=True):
-        """Constructor.
-
-        :param tree: The tree that will be transformed, but not necessarily
-            the output tree.
-        :param pb: ignored
-        :param case_sensitive: If True, the target of the transform is
-            case sensitive, not just case preserving.
-        """
-        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 = {}
-        # 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
-        # Whether the target is case sensitive
-        self._case_sensitive_target = case_sensitive
-
-    def finalize(self):
-        """Release the working tree lock, if held.
-
-        This is required if apply has not been invoked, but can be invoked
-        even after apply.
-        """
-        if self._tree is None:
-            return
-        for hook in MutableTree.hooks['post_transform']:
-            hook(self._tree, self)
-        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()
-        unique_add(self._new_name, trans_id, name)
-        unique_add(self._new_parent, trans_id, parent)
-        return trans_id
-
-    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
-
-        Instead of creating a root directory, or moving an existing directory,
-        all the attributes and children of the new root are applied to the
-        existing root directory.
-
-        This means that the old root trans-id becomes obsolete, so it is
-        recommended only to invoke this after the root trans-id has become
-        irrelevant.
-
-        """
-        new_roots = [k for k, v in viewitems(self._new_parent)
-                     if v == ROOT_PARENT]
-        if len(new_roots) < 1:
-            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:
-            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
-        # use directly-- some tree children have new parents
-        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)
-
-        # Ensure old_new_root has no directory.
-        if old_new_root in self._new_contents:
-            self.cancel_creation(old_new_root)
-        else:
-            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)
-
-        # destroy path info for old_new_root.
-        del self._new_parent[old_new_root]
-        del self._new_name[old_new_root]
-
-    def trans_id_file_id(self, file_id):
-        """Determine or set the transaction id associated with a file ID.
-        A new id is only created for file_ids that were never present.  If
-        a transaction has been unversioned, it is deliberately still returned.
-        (this will likely lead to an unversioned parent conflict.)
-        """
-        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)
-
-    def version_file(self, trans_id, file_id=None):
-        """Schedule a file to become versioned."""
-        raise NotImplementedError(self.version_file)
-
-    def cancel_versioning(self, trans_id):
-        """Undo a previous versioning of a file"""
-        raise NotImplementedError(self.cancel_versioning)
-
-    def new_paths(self, filesystem_only=False):
-        """Determine the paths of all new and changed files.
-
-        :param filesystem_only: if True, only calculate values for files
-            that require renames or execute bit changes.
-        """
-        new_ids = set()
-        if filesystem_only:
-            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)
-            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)
-        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
-
-    def find_conflicts(self):
-        """Find any violations of inventory or filesystem invariants"""
-        if self._done is True:
-            raise ReusingTransform()
-        conflicts = []
-        # ensure all children of all existent parents are known
-        # all children of non-existent parents are known, by definition.
-        self._add_tree_children()
-        by_parent = self.by_parent()
-        conflicts.extend(self._unversioned_parents(by_parent))
-        conflicts.extend(self._parent_loops())
-        conflicts.extend(self._duplicate_entries(by_parent))
-        conflicts.extend(self._parent_type_conflicts(by_parent))
-        conflicts.extend(self._improper_versioning())
-        conflicts.extend(self._executability_conflicts())
-        conflicts.extend(self._overwrite_conflicts())
-        return conflicts
-
-    def _check_malformed(self):
-        conflicts = self.find_conflicts()
-        if len(conflicts) != 0:
-            raise MalformedTransform(conflicts=conflicts)
-
-    def _add_tree_children(self):
-        """Add all the children of all active parents to the known paths.
-
-        Active parents are those which gain children, and those which are
-        removed.  This is a necessary first step in detecting conflicts.
-        """
-        parents = list(self.by_parent())
-        parents.extend([t for t in self._removed_contents if
-                        self.tree_kind(t) == 'directory'])
-        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)
-            elif self.tree_kind(trans_id) == 'directory':
-                parents.append(trans_id)
-
-        for parent_id in parents:
-            # ensure that all children are registered with the transaction
-            list(self.iter_tree_children(parent_id))
-
-    def _has_named_child(self, name, parent_id, known_children):
-        """Does a parent already have a name child.
-
-        :param name: The searched for name.
-
-        :param parent_id: The parent for which the check is made.
-
-        :param known_children: The already known children. This should have
-            been recently obtained from `self.by_parent.get(parent_id)`
-            (or will be if None is passed).
-        """
-        if known_children is None:
-            known_children = self.by_parent().get(parent_id, [])
-        for child in known_children:
-            if self.final_name(child) == name:
-                return True
-        parent_path = self._tree_id_paths.get(parent_id, None)
-        if parent_path is None:
-            # No parent... no children
-            return False
-        child_path = joinpath(parent_path, name)
-        child_id = self._tree_path_ids.get(child_path, None)
-        if child_id is None:
-            # Not known by the tree transform yet, check the filesystem
-            return osutils.lexists(self._tree.abspath(child_path))
-        else:
-            raise AssertionError('child_id is missing: %s, %s, %s'
-                                 % (name, parent_id, child_id))
-
-    def _available_backup_name(self, name, target_id):
-        """Find an available backup name.
-
-        :param name: The basename of the file.
-
-        :param target_id: The directory trans_id where the backup should
-            be placed.
-        """
-        known_children = self.by_parent().get(target_id, [])
-        return osutils.available_backup_name(
-            name,
-            lambda base: self._has_named_child(
-                base, target_id, known_children))
-
-    def _parent_loops(self):
-        """No entry should be its own ancestor"""
-        conflicts = []
-        for trans_id in self._new_parent:
-            seen = set()
-            parent_id = trans_id
-            while parent_id != ROOT_PARENT:
-                seen.add(parent_id)
-                try:
-                    parent_id = self.final_parent(parent_id)
-                except KeyError:
-                    break
-                if parent_id == trans_id:
-                    conflicts.append(('parent loop', trans_id))
-                if parent_id in seen:
-                    break
-        return conflicts
-
-    def _unversioned_parents(self, by_parent):
-        """If parent directories are versioned, children must be versioned."""
-        conflicts = []
-        for parent_id, children in viewitems(by_parent):
-            if parent_id == ROOT_PARENT:
-                continue
-            if self.final_is_versioned(parent_id):
-                continue
-            for child_id in children:
-                if self.final_is_versioned(child_id):
-                    conflicts.append(('unversioned parent', parent_id))
-                    break
-        return conflicts
-
-    def _improper_versioning(self):
-        """Cannot version a file with no contents, or a bad type.
-
-        However, existing entries with no contents are okay.
-        """
-        conflicts = []
-        for trans_id in self._new_id:
-            kind = self.final_kind(trans_id)
-            if kind == 'symlink' and not self._tree.supports_symlinks():
-                # Ignore symlinks as they are not supported on this platform
-                continue
-            if kind is None:
-                conflicts.append(('versioning no contents', trans_id))
-                continue
-            if not self._tree.versionable_kind(kind):
-                conflicts.append(('versioning bad kind', trans_id, kind))
-        return conflicts
-
-    def _executability_conflicts(self):
-        """Check for bad executability changes.
-
-        Only versioned files may have their executability set, because
-        1. only versioned entries can have executability under windows
-        2. only files can be executable.  (The execute bit on a directory
-           does not indicate searchability)
-        """
-        conflicts = []
-        for trans_id in self._new_executability:
-            if not self.final_is_versioned(trans_id):
-                conflicts.append(('unversioned executability', trans_id))
-            else:
-                if self.final_kind(trans_id) != "file":
-                    conflicts.append(('non-file executability', trans_id))
-        return conflicts
-
-    def _overwrite_conflicts(self):
-        """Check for overwrites (not permitted on Win32)"""
-        conflicts = []
-        for trans_id in self._new_contents:
-            if self.tree_kind(trans_id) is None:
-                continue
-            if trans_id not in self._removed_contents:
-                conflicts.append(('overwrite', trans_id,
-                                  self.final_name(trans_id)))
-        return conflicts
-
-    def _duplicate_entries(self, by_parent):
-        """No directory may have two entries with the same name."""
-        conflicts = []
-        if (self._new_name, self._new_parent) == ({}, {}):
-            return conflicts
-        for children in viewvalues(by_parent):
-            name_ids = []
-            for child_tid in children:
-                name = self.final_name(child_tid)
-                if name is not None:
-                    # Keep children only if they still exist in the end
-                    if not self._case_sensitive_target:
-                        name = name.lower()
-                    name_ids.append((name, child_tid))
-            name_ids.sort()
-            last_name = None
-            last_trans_id = None
-            for name, trans_id in name_ids:
-                kind = self.final_kind(trans_id)
-                if kind is None and not self.final_is_versioned(trans_id):
-                    continue
-                if name == last_name:
-                    conflicts.append(('duplicate', last_trans_id, trans_id,
-                                      name))
-                last_name = name
-                last_trans_id = trans_id
-        return conflicts
-
-    def _parent_type_conflicts(self, by_parent):
-        """Children must have a directory parent"""
-        conflicts = []
-        for parent_id, children in viewitems(by_parent):
-            if parent_id == ROOT_PARENT:
-                continue
-            no_children = True
-            for child_id in children:
-                if self.final_kind(child_id) is not None:
-                    no_children = False
-                    break
-            if no_children:
-                continue
-            # There is at least a child, so we need an existing directory to
-            # contain it.
-            kind = self.final_kind(parent_id)
-            if kind is None:
-                # The directory will be deleted
-                conflicts.append(('missing parent', parent_id))
-            elif kind != "directory":
-                # Meh, we need a *directory* to put something in it
-                conflicts.append(('non-directory parent', parent_id))
-        return conflicts
-
-    def _set_executability(self, path, trans_id):
-        """Set the executability of versioned files """
-        if self._tree._supports_executable():
-            new_executability = self._new_executability[trans_id]
-            abspath = self._tree.abspath(path)
-            current_mode = os.stat(abspath).st_mode
-            if new_executability:
-                umask = os.umask(0)
-                os.umask(umask)
-                to_mode = current_mode | (0o100 & ~umask)
-                # Enable x-bit for others only if they can read it.
-                if current_mode & 0o004:
-                    to_mode |= 0o001 & ~umask
-                if current_mode & 0o040:
-                    to_mode |= 0o010 & ~umask
-            else:
-                to_mode = current_mode & ~0o111
-            osutils.chmod_if_possible(abspath, to_mode)
-
-    def _new_entry(self, name, parent_id, file_id):
-        """Helper function to create a new filesystem entry."""
-        trans_id = self.create_path(name, parent_id)
-        if file_id is not None:
-            self.version_file(trans_id, file_id=file_id)
-        return trans_id
-
-    def new_file(self, name, parent_id, contents, file_id=None,
-                 executable=None, sha1=None):
-        """Convenience method to create files.
-
-        name is the name of the file to create.
-        parent_id is the transaction id of the parent directory of the file.
-        contents is an iterator of bytestrings, which will be used to produce
-        the file.
-        :param file_id: The inventory ID of the file, if it is to be versioned.
-        :param executable: Only valid when a file_id has been supplied.
-        """
-        trans_id = self._new_entry(name, parent_id, file_id)
-        # TODO: rather than scheduling a set_executable call,
-        # have create_file create the file with the right mode.
-        self.create_file(contents, trans_id, sha1=sha1)
-        if executable is not None:
-            self.set_executability(executable, trans_id)
-        return trans_id
-
-    def new_directory(self, name, parent_id, file_id=None):
-        """Convenience method to create directories.
-
-        name is the name of the directory to create.
-        parent_id is the transaction id of the parent directory of the
-        directory.
-        file_id is the inventory ID of the directory, if it is to be versioned.
-        """
-        trans_id = self._new_entry(name, parent_id, file_id)
-        self.create_directory(trans_id)
-        return trans_id
-
-    def new_symlink(self, name, parent_id, target, file_id=None):
-        """Convenience method to create symbolic link.
-
-        name is the name of the symlink to create.
-        parent_id is the transaction id of the parent directory of the symlink.
-        target is a bytestring of the target of the symlink.
-        file_id is the inventory ID of the file, if it is to be versioned.
-        """
-        trans_id = self._new_entry(name, parent_id, file_id)
-        self.create_symlink(target, trans_id)
-        return trans_id
-
-    def new_orphan(self, trans_id, parent_id):
-        """Schedule an item to be orphaned.
-
-        When a directory is about to be removed, its children, if they are not
-        versioned are moved out of the way: they don't have a parent anymore.
-
-        :param trans_id: The trans_id of the existing item.
-        :param parent_id: The parent trans_id of the item.
-        """
-        raise NotImplementedError(self.new_orphan)
-
-    def _get_potential_orphans(self, dir_id):
-        """Find the potential orphans in a directory.
-
-        A directory can't be safely deleted if there are versioned files in it.
-        If all the contained files are unversioned then they can be orphaned.
-
-        The 'None' return value means that the directory contains at least one
-        versioned file and should not be deleted.
-
-        :param dir_id: The directory trans id.
-
-        :return: A list of the orphan trans ids or None if at least one
-             versioned file is present.
-        """
-        orphans = []
-        # Find the potential orphans, stop if one item should be kept
-        for child_tid in self.by_parent()[dir_id]:
-            if child_tid in self._removed_contents:
-                # The child is removed as part of the transform. Since it was
-                # versioned before, it's not an orphan
-                continue
-            if not self.final_is_versioned(child_tid):
-                # The child is not versioned
-                orphans.append(child_tid)
-            else:
-                # We have a versioned file here, searching for orphans is
-                # meaningless.
-                orphans = None
-                break
-        return orphans
-
-    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._removed_contents)
-        trans_ids.update(self._new_contents)
-        trans_ids.update(self._new_executability)
-        trans_ids.update(self._new_name)
-        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):
-        """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_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()
-        results = []
-        # Now iterate through all active file_ids
-        for file_id in set(from_trans_ids).union(to_trans_ids):
-            modified = False
-            from_trans_id = from_trans_ids.get(file_id)
-            # find file ids, and determine versioning state
-            if from_trans_id 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:
-                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:
-                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:
-                modified = True
-            elif to_kind in ('file', 'symlink') and (
-                    to_trans_id != from_trans_id
-                    or to_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_executable == to_executable):
-                continue
-            results.append(
-                TreeChange(
-                    file_id, (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)))
-
-        def path_key(c):
-            return (c.path[0] or '', c.path[1] or '')
-        return iter(sorted(results, key=path_key))
-
-    def get_preview_tree(self):
-        """Return a tree representing the result of the transform.
-
-        The tree is a snapshot, and altering the TreeTransform will invalidate
-        it.
-        """
-        raise NotImplementedError(self.get_preview)
-
-    def commit(self, branch, message, merge_parents=None, strict=False,
-               timestamp=None, timezone=None, committer=None, authors=None,
-               revprops=None, revision_id=None):
-        """Commit the result of this TreeTransform to a branch.
-
-        :param branch: The branch to commit to.
-        :param message: The message to attach to the commit.
-        :param merge_parents: Additional parent revision-ids specified by
-            pending merges.
-        :param strict: If True, abort the commit if there are unversioned
-            files.
-        :param timestamp: if not None, seconds-since-epoch for the time and
-            date.  (May be a float.)
-        :param timezone: Optional timezone for timestamp, as an offset in
-            seconds.
-        :param committer: Optional committer in email-id format.
-            (e.g. "J Random Hacker <[e-mail]>")
-        :param authors: Optional list of authors in email-id format.
-        :param revprops: Optional dictionary of revision properties.
-        :param revision_id: Optional revision id.  (Specifying a revision-id
-            may reduce performance for some non-native formats.)
-        :return: The revision_id of the revision committed.
-        """
-        self._check_malformed()
-        if strict:
-            unversioned = set(self._new_contents).difference(set(self._new_id))
-            for trans_id in unversioned:
-                if not self.final_is_versioned(trans_id):
-                    raise errors.StrictCommitFailed()
-
-        revno, last_rev_id = branch.last_revision_info()
-        if last_rev_id == _mod_revision.NULL_REVISION:
-            if merge_parents is not None:
-                raise ValueError('Cannot supply merge parents for first'
-                                 ' commit.')
-            parent_ids = []
-        else:
-            parent_ids = [last_rev_id]
-            if merge_parents is not None:
-                parent_ids.extend(merge_parents)
-        if self._tree.get_revision_id() != last_rev_id:
-            raise ValueError('TreeTransform not based on branch basis: %s' %
-                             self._tree.get_revision_id().decode('utf-8'))
-        from . import commit
-        revprops = commit.Commit.update_revprops(revprops, branch, authors)
-        builder = branch.get_commit_builder(parent_ids,
-                                            timestamp=timestamp,
-                                            timezone=timezone,
-                                            committer=committer,
-                                            revprops=revprops,
-                                            revision_id=revision_id)
-        preview = self.get_preview_tree()
-        list(builder.record_iter_changes(preview, last_rev_id,
-                                         self.iter_changes()))
-        builder.finish_inventory()
-        revision_id = builder.commit(message)
-        branch.set_last_revision_info(revno + 1, revision_id)
-        return revision_id
-
-    def _text_parent(self, trans_id):
-        path = self.tree_path(trans_id)
-        try:
-            if path is None or self._tree.kind(path) != 'file':
-                return None
-        except errors.NoSuchFile:
-            return None
-        return path
-
-    def _get_parents_texts(self, trans_id):
-        """Get texts for compression parents of this file."""
-        path = self._text_parent(trans_id)
-        if path is None:
-            return ()
-        return (self._tree.get_file_text(path),)
-
-    def _get_parents_lines(self, trans_id):
-        """Get lines for compression parents of this file."""
-        path = self._text_parent(trans_id)
-        if path is None:
-            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.
-
-        :seealso: new_file.
-
-        :param contents: an iterator of strings, all of which will be written
-            to the target destination.
-        :param trans_id: TreeTransform handle
-        :param mode_id: If not None, force the mode of the target file to match
-            the mode of the object referenced by mode_id.
-            Otherwise, we will try to preserve mode bits of an existing file.
-        :param sha1: If the sha1 of this content is already known, pass it in.
-            We can use it to prevent future sha1 computations.
-        """
-        raise NotImplementedError(self.create_file)
-
-    def create_directory(self, trans_id):
-        """Schedule creation of a new directory.
-
-        See also new_directory.
-        """
-        raise NotImplementedError(self.create_directory)
-
-    def create_symlink(self, target, trans_id):
-        """Schedule creation of a new symbolic link.
-
-        target is a bytestring.
-        See also new_symlink.
-        """
-        raise NotImplementedError(self.create_symlink)
-
-    def create_hardlink(self, path, trans_id):
-        """Schedule creation of a hard link"""
-        raise NotImplementedError(self.create_hardlink)
-
-    def cancel_creation(self, trans_id):
-        """Cancel the creation of new file contents."""
-        raise NotImplementedError(self.cancel_creation)
-
-    def apply(self, no_conflicts=False, precomputed_delta=None, _mover=None):
-        """Apply all changes to the inventory and filesystem.
-
-        If filesystem or inventory conflicts are present, MalformedTransform
-        will be thrown.
-
-        If apply succeeds, finalize is not necessary.
-
-        :param no_conflicts: if True, the caller guarantees there are no
-            conflicts, so no check is made.
-        :param precomputed_delta: An inventory delta to use instead of
-            calculating one.
-        :param _mover: Supply an alternate FileMover, for testing
-        """
-        raise NotImplementedError(self.apply)
-
-
-class DiskTreeTransform(TreeTransformBase):
-    """Tree transform storing its contents on disk."""
-
-    def __init__(self, tree, limbodir, pb=None, case_sensitive=True):
-        """Constructor.
-        :param tree: The tree that will be transformed, but not necessarily
-            the output tree.
-        :param limbodir: A directory where new files can be stored until
-            they are installed in their proper places
-        :param pb: ignored
-        :param case_sensitive: If True, the target of the transform is
-            case sensitive, not just case preserving.
-        """
-        TreeTransformBase.__init__(self, tree, pb, case_sensitive)
-        self._limbodir = limbodir
-        self._deletiondir = None
-        # A mapping of transform ids to their limbo filename
-        self._limbo_files = {}
-        self._possibly_stale_limbo_files = set()
-        # A mapping of transform ids to a set of the transform ids of children
-        # that their limbo directory has
-        self._limbo_children = {}
-        # Map transform ids to maps of child filename to child transform id
-        self._limbo_children_names = {}
-        # List of transform ids that need to be renamed from limbo into place
-        self._needs_rename = set()
-        self._creation_mtime = None
-        self._create_symlinks = osutils.supports_symlinks(self._limbodir)
-
-    def finalize(self):
-        """Release the working tree lock, if held, clean up limbo dir.
-
-        This is required if apply has not been invoked, but can be invoked
-        even after apply.
-        """
-        if self._tree is None:
-            return
-        try:
-            limbo_paths = list(viewvalues(self._limbo_files))
-            limbo_paths.extend(self._possibly_stale_limbo_files)
-            limbo_paths.sort(reverse=True)
-            for path in limbo_paths:
-                try:
-                    delete_any(path)
-                except OSError as e:
-                    if e.errno != errno.ENOENT:
-                        raise
-                    # XXX: warn? perhaps we just got interrupted at an
-                    # inconvenient moment, but perhaps files are disappearing
-                    # from under us?
-            try:
-                delete_any(self._limbodir)
-            except OSError:
-                # We don't especially care *why* the dir is immortal.
-                raise ImmortalLimbo(self._limbodir)
-            try:
-                if self._deletiondir is not None:
-                    delete_any(self._deletiondir)
-            except OSError:
-                raise errors.ImmortalPendingDeletion(self._deletiondir)
-        finally:
-            TreeTransformBase.finalize(self)
-
-    def _limbo_supports_executable(self):
-        """Check if the limbo path supports the executable bit."""
-        return osutils.supports_executable(self._limbodir)
-
-    def _limbo_name(self, trans_id):
-        """Generate the limbo name of a file"""
-        limbo_name = self._limbo_files.get(trans_id)
-        if limbo_name is None:
-            limbo_name = self._generate_limbo_path(trans_id)
-            self._limbo_files[trans_id] = limbo_name
-        return limbo_name
-
-    def _generate_limbo_path(self, trans_id):
-        """Generate a limbo path using the trans_id as the relative path.
-
-        This is suitable as a fallback, and when the transform should not be
-        sensitive to the path encoding of the limbo directory.
-        """
-        self._needs_rename.add(trans_id)
-        return pathjoin(self._limbodir, trans_id)
-
-    def adjust_path(self, name, parent, trans_id):
-        previous_parent = self._new_parent.get(trans_id)
-        previous_name = self._new_name.get(trans_id)
-        super(DiskTreeTransform, self).adjust_path(name, parent, trans_id)
-        if (trans_id in self._limbo_files
-                and trans_id not in self._needs_rename):
-            self._rename_in_limbo([trans_id])
-            if previous_parent != parent:
-                self._limbo_children[previous_parent].remove(trans_id)
-            if previous_parent != parent or previous_name != name:
-                del self._limbo_children_names[previous_parent][previous_name]
-
-    def _rename_in_limbo(self, trans_ids):
-        """Fix limbo names so that the right final path is produced.
-
-        This means we outsmarted ourselves-- we tried to avoid renaming
-        these files later by creating them with their final names in their
-        final parents.  But now the previous name or parent is no longer
-        suitable, so we have to rename them.
-
-        Even for trans_ids that have no new contents, we must remove their
-        entries from _limbo_files, because they are now stale.
-        """
-        for trans_id in trans_ids:
-            old_path = self._limbo_files[trans_id]
-            self._possibly_stale_limbo_files.add(old_path)
-            del self._limbo_files[trans_id]
-            if trans_id not in self._new_contents:
-                continue
-            new_path = self._limbo_name(trans_id)
-            os.rename(old_path, new_path)
-            self._possibly_stale_limbo_files.remove(old_path)
-            for descendant in self._limbo_descendants(trans_id):
-                desc_path = self._limbo_files[descendant]
-                desc_path = new_path + desc_path[len(old_path):]
-                self._limbo_files[descendant] = desc_path
-
-    def _limbo_descendants(self, trans_id):
-        """Return the set of trans_ids whose limbo paths descend from this."""
-        descendants = set(self._limbo_children.get(trans_id, []))
-        for descendant in list(descendants):
-            descendants.update(self._limbo_descendants(descendant))
-        return descendants
-
-    def _set_mode(self, trans_id, mode_id, typefunc):
-        raise NotImplementedError(self._set_mode)
-
-    def create_file(self, contents, trans_id, mode_id=None, sha1=None):
-        """Schedule creation of a new file.
-
-        :seealso: new_file.
-
-        :param contents: an iterator of strings, all of which will be written
-            to the target destination.
-        :param trans_id: TreeTransform handle
-        :param mode_id: If not None, force the mode of the target file to match
-            the mode of the object referenced by mode_id.
-            Otherwise, we will try to preserve mode bits of an existing file.
-        :param sha1: If the sha1 of this content is already known, pass it in.
-            We can use it to prevent future sha1 computations.
-        """
-        name = self._limbo_name(trans_id)
-        with open(name, 'wb') as f:
-            unique_add(self._new_contents, trans_id, 'file')
-            f.writelines(contents)
-        self._set_mtime(name)
-        self._set_mode(trans_id, mode_id, S_ISREG)
-        # It is unfortunate we have to use lstat instead of fstat, but we just
-        # used utime and chmod on the file, so we need the accurate final
-        # details.
-        if sha1 is not None:
-            self._observed_sha1s[trans_id] = (sha1, osutils.lstat(name))
-
-    def _read_symlink_target(self, trans_id):
-        return os.readlink(self._limbo_name(trans_id))
-
-    def _set_mtime(self, path):
-        """All files that are created get the same mtime.
-
-        This time is set by the first object to be created.
-        """
-        if self._creation_mtime is None:
-            self._creation_mtime = time.time()
-        os.utime(path, (self._creation_mtime, self._creation_mtime))
-
-    def create_hardlink(self, path, trans_id):
-        """Schedule creation of a hard link"""
-        name = self._limbo_name(trans_id)
-        try:
-            os.link(path, name)
-        except OSError as e:
-            if e.errno != errno.EPERM:
-                raise
-            raise errors.HardLinkNotSupported(path)
-        try:
-            unique_add(self._new_contents, trans_id, 'file')
-        except BaseException:
-            # Clean up the file, it never got registered so
-            # TreeTransform.finalize() won't clean it up.
-            os.unlink(name)
-            raise
-
-    def create_directory(self, trans_id):
-        """Schedule creation of a new directory.
-
-        See also new_directory.
-        """
-        os.mkdir(self._limbo_name(trans_id))
-        unique_add(self._new_contents, trans_id, 'directory')
-
-    def create_symlink(self, target, trans_id):
-        """Schedule creation of a new symbolic link.
-
-        target is a bytestring.
-        See also new_symlink.
-        """
-        if self._create_symlinks:
-            os.symlink(target, self._limbo_name(trans_id))
-        else:
-            try:
-                path = FinalPaths(self).get_path(trans_id)
-            except KeyError:
-                path = None
-            trace.warning(
-                'Unable to create symlink "%s" on this filesystem.' % (path,))
-        # 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
-        unique_add(self._new_contents, trans_id, 'symlink')
-
-    def cancel_creation(self, trans_id):
-        """Cancel the creation of new file contents."""
-        del self._new_contents[trans_id]
-        if trans_id in self._observed_sha1s:
-            del self._observed_sha1s[trans_id]
-        children = self._limbo_children.get(trans_id)
-        # if this is a limbo directory with children, move them before removing
-        # the directory
-        if children is not None:
-            self._rename_in_limbo(children)
-            del self._limbo_children[trans_id]
-            del self._limbo_children_names[trans_id]
-        delete_any(self._limbo_name(trans_id))
-
-    def new_orphan(self, trans_id, parent_id):
-        conf = self._tree.get_config_stack()
-        handle_orphan = conf.get('transform.orphan_policy')
-        handle_orphan(self, trans_id, parent_id)
-
-
 class OrphaningError(errors.BzrError):
 
     # Only bugs could lead to such exception being seen by the user