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

[Jelmer Vernooij]

Merge lp:brz/3.1.

Merge lp:brz/3.1.

[Jelmer Vernooij (jelmer)]

review: Approve

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

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

=== modified file 'breezy/builtins.py'
--- breezy/builtins.py	2020-07-18 23:14:00 +0000
+++ breezy/builtins.py	2020-08-23 01:05:31 +0000
@@ -61,7 +61,6 @@
     views,
     )
 from breezy.branch import Branch
-from breezy.conflicts import ConflictList
 from breezy.transport import memory
 from breezy.smtp_connection import SMTPConnection
 from breezy.workingtree import WorkingTree
@@ -4820,7 +4819,7 @@
             restore_files = [c.path for c in conflicts
                              if c.typestring in allowed_conflicts]
         _mod_merge.transform_tree(tree, tree.basis_tree(), interesting_files)
-        tree.set_conflicts(ConflictList(new_conflicts))
+        tree.set_conflicts(new_conflicts)
         if file_list is not None:
             restore_files = file_list
         for filename in restore_files:

=== modified file 'breezy/bzr/_dirstate_helpers_pyx.pyx'
--- breezy/bzr/_dirstate_helpers_pyx.pyx	2020-06-08 19:42:53 +0000
+++ breezy/bzr/_dirstate_helpers_pyx.pyx	2020-08-23 01:05:31 +0000
@@ -31,7 +31,7 @@
 from .. import cache_utf8, errors, osutils
 from .dirstate import DirState, DirstateCorrupt
 from ..osutils import parent_directories, pathjoin, splitpath, is_inside_any, is_inside
-from ..tree import TreeChange
+from .inventorytree import InventoryTreeChange
 
 
 # This is the Windows equivalent of ENOTDIR
@@ -1303,7 +1303,7 @@
                     else:
                         path_u = self.utf8_decode(path)[0]
                 source_kind = _minikind_to_kind(source_minikind)
-                return TreeChange(entry[0][2],
+                return InventoryTreeChange(entry[0][2],
                        (old_path_u, path_u),
                        content_change,
                        (True, True),
@@ -1336,7 +1336,7 @@
                         and S_IXUSR & path_info[3].st_mode)
                 else:
                     target_exec = target_details[3]
-                return TreeChange(entry[0][2],
+                return InventoryTreeChange(entry[0][2],
                        (None, self.utf8_decode(path)[0]),
                        True,
                        (False, True),
@@ -1346,7 +1346,7 @@
                        (None, target_exec)), True
             else:
                 # Its a missing file, report it as such.
-                return TreeChange(entry[0][2],
+                return InventoryTreeChange(entry[0][2],
                        (None, self.utf8_decode(path)[0]),
                        False,
                        (False, True),
@@ -1364,7 +1364,7 @@
             parent_id = self.state._get_entry(self.source_index, path_utf8=entry[0][0])[0][2]
             if parent_id == entry[0][2]:
                 parent_id = None
-            return TreeChange(
+            return InventoryTreeChange(
                    entry[0][2],
                    (self.utf8_decode(old_path)[0], None),
                    True,
@@ -1562,7 +1562,7 @@
                 new_executable = bool(
                     stat.S_ISREG(self.root_dir_info[3].st_mode)
                     and stat.S_IEXEC & self.root_dir_info[3].st_mode)
-                return TreeChange(
+                return InventoryTreeChange(
                        None,
                        (None, self.current_root_unicode),
                        True,
@@ -1674,7 +1674,7 @@
                             new_executable = bool(
                                 stat.S_ISREG(current_path_info[3].st_mode)
                                 and stat.S_IEXEC & current_path_info[3].st_mode)
-                            return TreeChange(
+                            return InventoryTreeChange(
                                 None,
                                 (None, self.utf8_decode(current_path_info[0])[0]),
                                 True,
@@ -1844,7 +1844,7 @@
                             if changed is not None:
                                 raise AssertionError(
                                     "result is not None: %r" % result)
-                            result = TreeChange(
+                            result = InventoryTreeChange(
                                 None,
                                 (None, relpath_unicode),
                                 True,

=== added file 'breezy/bzr/conflicts.py'
--- breezy/bzr/conflicts.py	1970-01-01 00:00:00 +0000
+++ breezy/bzr/conflicts.py	2020-08-23 01:05:31 +0000
@@ -0,0 +1,663 @@
+# Copyright (C) 2005, 2006, 2007, 2009, 2010, 2011 Canonical Ltd
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
+from __future__ import absolute_import
+
+import errno
+import os
+import re
+
+from ..lazy_import import lazy_import
+lazy_import(globals(), """
+
+from breezy import (
+    cache_utf8,
+    errors,
+    rio,
+    transform,
+    osutils,
+    )
+""")
+
+from ..conflicts import (
+    Conflict as BaseConflict,
+    ConflictList as BaseConflictList,
+    )
+
+
+CONFLICT_SUFFIXES = ('.THIS', '.BASE', '.OTHER')
+
+
+class Conflict(BaseConflict):
+    """Base class for all types of conflict"""
+
+    # FIXME: cleanup should take care of that ? -- vila 091229
+    has_files = False
+
+    def __init__(self, path, file_id=None):
+        super(Conflict, self).__init__(path)
+        # the factory blindly transfers the Stanza values to __init__ and
+        # Stanza is purely a Unicode api.
+        if isinstance(file_id, str):
+            file_id = cache_utf8.encode(file_id)
+        self.file_id = file_id
+
+    def as_stanza(self):
+        s = rio.Stanza(type=self.typestring, path=self.path)
+        if self.file_id is not None:
+            # Stanza requires Unicode apis
+            s.add('file_id', self.file_id.decode('utf8'))
+        return s
+
+    def _cmp_list(self):
+        return [type(self), self.path, self.file_id]
+
+    def __cmp__(self, other):
+        if getattr(other, "_cmp_list", None) is None:
+            return -1
+        x = self._cmp_list()
+        y = other._cmp_list()
+        return (x > y) - (x < y)
+
+    def __hash__(self):
+        return hash((type(self), self.path, self.file_id))
+
+    def __eq__(self, other):
+        return self.__cmp__(other) == 0
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    def __unicode__(self):
+        return self.describe()
+
+    def __str__(self):
+        return self.describe()
+
+    def describe(self):
+        return self.format % self.__dict__
+
+    def __repr__(self):
+        rdict = dict(self.__dict__)
+        rdict['class'] = self.__class__.__name__
+        return self.rformat % rdict
+
+    @staticmethod
+    def factory(type, **kwargs):
+        global ctype
+        return ctype[type](**kwargs)
+
+    @staticmethod
+    def sort_key(conflict):
+        if conflict.path is not None:
+            return conflict.path, conflict.typestring
+        elif getattr(conflict, "conflict_path", None) is not None:
+            return conflict.conflict_path, conflict.typestring
+        else:
+            return None, conflict.typestring
+
+    def do(self, action, tree):
+        """Apply the specified action to the conflict.
+
+        :param action: The method name to call.
+
+        :param tree: The tree passed as a parameter to the method.
+        """
+        meth = getattr(self, 'action_%s' % action, None)
+        if meth is None:
+            raise NotImplementedError(self.__class__.__name__ + '.' + action)
+        meth(tree)
+
+    def action_auto(self, tree):
+        raise NotImplementedError(self.action_auto)
+
+    def action_done(self, tree):
+        """Mark the conflict as solved once it has been handled."""
+        # This method does nothing but simplifies the design of upper levels.
+        pass
+
+    def action_take_this(self, tree):
+        raise NotImplementedError(self.action_take_this)
+
+    def action_take_other(self, tree):
+        raise NotImplementedError(self.action_take_other)
+
+    def _resolve_with_cleanups(self, tree, *args, **kwargs):
+        with tree.transform() as tt:
+            self._resolve(tt, *args, **kwargs)
+
+
+class ConflictList(BaseConflictList):
+
+    @staticmethod
+    def from_stanzas(stanzas):
+        """Produce a new ConflictList from an iterable of stanzas"""
+        conflicts = ConflictList()
+        for stanza in stanzas:
+            conflicts.append(Conflict.factory(**stanza.as_dict()))
+        return conflicts
+
+    def to_stanzas(self):
+        """Generator of stanzas"""
+        for conflict in self:
+            yield conflict.as_stanza()
+
+    def select_conflicts(self, tree, paths, ignore_misses=False,
+                         recurse=False):
+        """Select the conflicts associated with paths in a tree.
+
+        File-ids are also used for this.
+        :return: a pair of ConflictLists: (not_selected, selected)
+        """
+        path_set = set(paths)
+        ids = {}
+        selected_paths = set()
+        new_conflicts = ConflictList()
+        selected_conflicts = ConflictList()
+        for path in paths:
+            file_id = tree.path2id(path)
+            if file_id is not None:
+                ids[file_id] = path
+
+        for conflict in self:
+            selected = False
+            for key in ('path', 'conflict_path'):
+                cpath = getattr(conflict, key, None)
+                if cpath is None:
+                    continue
+                if cpath in path_set:
+                    selected = True
+                    selected_paths.add(cpath)
+                if recurse:
+                    if osutils.is_inside_any(path_set, cpath):
+                        selected = True
+                        selected_paths.add(cpath)
+
+            for key in ('file_id', 'conflict_file_id'):
+                cfile_id = getattr(conflict, key, None)
+                if cfile_id is None:
+                    continue
+                try:
+                    cpath = ids[cfile_id]
+                except KeyError:
+                    continue
+                selected = True
+                selected_paths.add(cpath)
+            if selected:
+                selected_conflicts.append(conflict)
+            else:
+                new_conflicts.append(conflict)
+        if ignore_misses is not True:
+            for path in [p for p in paths if p not in selected_paths]:
+                if not os.path.exists(tree.abspath(path)):
+                    print("%s does not exist" % path)
+                else:
+                    print("%s is not conflicted" % path)
+        return new_conflicts, selected_conflicts
+
+
+
+
+class PathConflict(Conflict):
+    """A conflict was encountered merging file paths"""
+
+    typestring = 'path conflict'
+
+    format = 'Path conflict: %(path)s / %(conflict_path)s'
+
+    rformat = '%(class)s(%(path)r, %(conflict_path)r, %(file_id)r)'
+
+    def __init__(self, path, conflict_path=None, file_id=None):
+        Conflict.__init__(self, path, file_id)
+        self.conflict_path = conflict_path
+
+    def as_stanza(self):
+        s = Conflict.as_stanza(self)
+        if self.conflict_path is not None:
+            s.add('conflict_path', self.conflict_path)
+        return s
+
+    def associated_filenames(self):
+        # No additional files have been generated here
+        return []
+
+    def _resolve(self, tt, file_id, path, winner):
+        """Resolve the conflict.
+
+        :param tt: The TreeTransform where the conflict is resolved.
+        :param file_id: The retained file id.
+        :param path: The retained path.
+        :param winner: 'this' or 'other' indicates which side is the winner.
+        """
+        path_to_create = None
+        if winner == 'this':
+            if self.path == '<deleted>':
+                return  # Nothing to do
+            if self.conflict_path == '<deleted>':
+                path_to_create = self.path
+                revid = tt._tree.get_parent_ids()[0]
+        elif winner == 'other':
+            if self.conflict_path == '<deleted>':
+                return  # Nothing to do
+            if self.path == '<deleted>':
+                path_to_create = self.conflict_path
+                # FIXME: If there are more than two parents we may need to
+                # iterate. Taking the last parent is the safer bet in the mean
+                # time. -- vila 20100309
+                revid = tt._tree.get_parent_ids()[-1]
+        else:
+            # Programmer error
+            raise AssertionError('bad winner: %r' % (winner,))
+        if path_to_create is not None:
+            tid = tt.trans_id_tree_path(path_to_create)
+            tree = self._revision_tree(tt._tree, revid)
+            transform.create_from_tree(
+                tt, tid, tree, tree.id2path(file_id))
+            tt.version_file(tid, file_id=file_id)
+        else:
+            tid = tt.trans_id_file_id(file_id)
+        # Adjust the path for the retained file id
+        parent_tid = tt.get_tree_parent(tid)
+        tt.adjust_path(osutils.basename(path), parent_tid, tid)
+        tt.apply()
+
+    def _revision_tree(self, tree, revid):
+        return tree.branch.repository.revision_tree(revid)
+
+    def _infer_file_id(self, tree):
+        # Prior to bug #531967, file_id wasn't always set, there may still be
+        # conflict files in the wild so we need to cope with them
+        # Establish which path we should use to find back the file-id
+        possible_paths = []
+        for p in (self.path, self.conflict_path):
+            if p == '<deleted>':
+                # special hard-coded path
+                continue
+            if p is not None:
+                possible_paths.append(p)
+        # Search the file-id in the parents with any path available
+        file_id = None
+        for revid in tree.get_parent_ids():
+            revtree = self._revision_tree(tree, revid)
+            for p in possible_paths:
+                file_id = revtree.path2id(p)
+                if file_id is not None:
+                    return revtree, file_id
+        return None, None
+
+    def action_take_this(self, tree):
+        if self.file_id is not None:
+            self._resolve_with_cleanups(tree, self.file_id, self.path,
+                                        winner='this')
+        else:
+            # Prior to bug #531967 we need to find back the file_id and restore
+            # the content from there
+            revtree, file_id = self._infer_file_id(tree)
+            tree.revert([revtree.id2path(file_id)],
+                        old_tree=revtree, backups=False)
+
+    def action_take_other(self, tree):
+        if self.file_id is not None:
+            self._resolve_with_cleanups(tree, self.file_id,
+                                        self.conflict_path,
+                                        winner='other')
+        else:
+            # Prior to bug #531967 we need to find back the file_id and restore
+            # the content from there
+            revtree, file_id = self._infer_file_id(tree)
+            tree.revert([revtree.id2path(file_id)],
+                        old_tree=revtree, backups=False)
+
+
+class ContentsConflict(PathConflict):
+    """The files are of different types (or both binary), or not present"""
+
+    has_files = True
+
+    typestring = 'contents conflict'
+
+    format = 'Contents conflict in %(path)s'
+
+    def associated_filenames(self):
+        return [self.path + suffix for suffix in ('.BASE', '.OTHER')]
+
+    def _resolve(self, tt, suffix_to_remove):
+        """Resolve the conflict.
+
+        :param tt: The TreeTransform where the conflict is resolved.
+        :param suffix_to_remove: Either 'THIS' or 'OTHER'
+
+        The resolution is symmetric: when taking THIS, OTHER is deleted and
+        item.THIS is renamed into item and vice-versa.
+        """
+        try:
+            # Delete 'item.THIS' or 'item.OTHER' depending on
+            # suffix_to_remove
+            tt.delete_contents(
+                tt.trans_id_tree_path(self.path + '.' + suffix_to_remove))
+        except errors.NoSuchFile:
+            # There are valid cases where 'item.suffix_to_remove' either
+            # never existed or was already deleted (including the case
+            # where the user deleted it)
+            pass
+        try:
+            this_path = tt._tree.id2path(self.file_id)
+        except errors.NoSuchId:
+            # The file is not present anymore. This may happen if the user
+            # deleted the file either manually or when resolving a conflict on
+            # the parent.  We may raise some exception to indicate that the
+            # conflict doesn't exist anymore and as such doesn't need to be
+            # resolved ? -- vila 20110615
+            this_tid = None
+        else:
+            this_tid = tt.trans_id_tree_path(this_path)
+        if this_tid is not None:
+            # Rename 'item.suffix_to_remove' (note that if
+            # 'item.suffix_to_remove' has been deleted, this is a no-op)
+            parent_tid = tt.get_tree_parent(this_tid)
+            tt.adjust_path(osutils.basename(self.path), parent_tid, this_tid)
+            tt.apply()
+
+    def action_take_this(self, tree):
+        self._resolve_with_cleanups(tree, 'OTHER')
+
+    def action_take_other(self, tree):
+        self._resolve_with_cleanups(tree, 'THIS')
+
+
+# TODO: There should be a base revid attribute to better inform the user about
+# how the conflicts were generated.
+class TextConflict(Conflict):
+    """The merge algorithm could not resolve all differences encountered."""
+
+    has_files = True
+
+    typestring = 'text conflict'
+
+    format = 'Text conflict in %(path)s'
+
+    rformat = '%(class)s(%(path)r, %(file_id)r)'
+
+    _conflict_re = re.compile(b'^(<{7}|={7}|>{7})')
+
+    def associated_filenames(self):
+        return [self.path + suffix for suffix in CONFLICT_SUFFIXES]
+
+    def _resolve(self, tt, winner_suffix):
+        """Resolve the conflict by copying one of .THIS or .OTHER into file.
+
+        :param tt: The TreeTransform where the conflict is resolved.
+        :param winner_suffix: Either 'THIS' or 'OTHER'
+
+        The resolution is symmetric, when taking THIS, item.THIS is renamed
+        into item and vice-versa. This takes one of the files as a whole
+        ignoring every difference that could have been merged cleanly.
+        """
+        # To avoid useless copies, we switch item and item.winner_suffix, only
+        # item will exist after the conflict has been resolved anyway.
+        item_tid = tt.trans_id_file_id(self.file_id)
+        item_parent_tid = tt.get_tree_parent(item_tid)
+        winner_path = self.path + '.' + winner_suffix
+        winner_tid = tt.trans_id_tree_path(winner_path)
+        winner_parent_tid = tt.get_tree_parent(winner_tid)
+        # Switch the paths to preserve the content
+        tt.adjust_path(osutils.basename(self.path),
+                       winner_parent_tid, winner_tid)
+        tt.adjust_path(osutils.basename(winner_path),
+                       item_parent_tid, item_tid)
+        # Associate the file_id to the right content
+        tt.unversion_file(item_tid)
+        tt.version_file(winner_tid, file_id=self.file_id)
+        tt.apply()
+
+    def action_auto(self, tree):
+        # GZ 2012-07-27: Using NotImplementedError to signal that a conflict
+        #                can't be auto resolved does not seem ideal.
+        try:
+            kind = tree.kind(self.path)
+        except errors.NoSuchFile:
+            return
+        if kind != 'file':
+            raise NotImplementedError("Conflict is not a file")
+        conflict_markers_in_line = self._conflict_re.search
+        # GZ 2012-07-27: What if not tree.has_id(self.file_id) due to removal?
+        with tree.get_file(self.path) as f:
+            for line in f:
+                if conflict_markers_in_line(line):
+                    raise NotImplementedError("Conflict markers present")
+
+    def action_take_this(self, tree):
+        self._resolve_with_cleanups(tree, 'THIS')
+
+    def action_take_other(self, tree):
+        self._resolve_with_cleanups(tree, 'OTHER')
+
+
+class HandledConflict(Conflict):
+    """A path problem that has been provisionally resolved.
+    This is intended to be a base class.
+    """
+
+    rformat = "%(class)s(%(action)r, %(path)r, %(file_id)r)"
+
+    def __init__(self, action, path, file_id=None):
+        Conflict.__init__(self, path, file_id)
+        self.action = action
+
+    def _cmp_list(self):
+        return Conflict._cmp_list(self) + [self.action]
+
+    def as_stanza(self):
+        s = Conflict.as_stanza(self)
+        s.add('action', self.action)
+        return s
+
+    def associated_filenames(self):
+        # Nothing has been generated here
+        return []
+
+
+class HandledPathConflict(HandledConflict):
+    """A provisionally-resolved path problem involving two paths.
+    This is intended to be a base class.
+    """
+
+    rformat = "%(class)s(%(action)r, %(path)r, %(conflict_path)r,"\
+        " %(file_id)r, %(conflict_file_id)r)"
+
+    def __init__(self, action, path, conflict_path, file_id=None,
+                 conflict_file_id=None):
+        HandledConflict.__init__(self, action, path, file_id)
+        self.conflict_path = conflict_path
+        # the factory blindly transfers the Stanza values to __init__,
+        # so they can be unicode.
+        if isinstance(conflict_file_id, str):
+            conflict_file_id = cache_utf8.encode(conflict_file_id)
+        self.conflict_file_id = conflict_file_id
+
+    def _cmp_list(self):
+        return HandledConflict._cmp_list(self) + [self.conflict_path,
+                                                  self.conflict_file_id]
+
+    def as_stanza(self):
+        s = HandledConflict.as_stanza(self)
+        s.add('conflict_path', self.conflict_path)
+        if self.conflict_file_id is not None:
+            s.add('conflict_file_id', self.conflict_file_id.decode('utf8'))
+
+        return s
+
+
+class DuplicateID(HandledPathConflict):
+    """Two files want the same file_id."""
+
+    typestring = 'duplicate id'
+
+    format = 'Conflict adding id to %(conflict_path)s.  %(action)s %(path)s.'
+
+
+class DuplicateEntry(HandledPathConflict):
+    """Two directory entries want to have the same name."""
+
+    typestring = 'duplicate'
+
+    format = 'Conflict adding file %(conflict_path)s.  %(action)s %(path)s.'
+
+    def action_take_this(self, tree):
+        tree.remove([self.conflict_path], force=True, keep_files=False)
+        tree.rename_one(self.path, self.conflict_path)
+
+    def action_take_other(self, tree):
+        tree.remove([self.path], force=True, keep_files=False)
+
+
+class ParentLoop(HandledPathConflict):
+    """An attempt to create an infinitely-looping directory structure.
+    This is rare, but can be produced like so:
+
+    tree A:
+      mv foo bar
+    tree B:
+      mv bar foo
+    merge A and B
+    """
+
+    typestring = 'parent loop'
+
+    format = 'Conflict moving %(path)s into %(conflict_path)s. %(action)s.'
+
+    def action_take_this(self, tree):
+        # just acccept brz proposal
+        pass
+
+    def action_take_other(self, tree):
+        with tree.transform() as tt:
+            p_tid = tt.trans_id_file_id(self.file_id)
+            parent_tid = tt.get_tree_parent(p_tid)
+            cp_tid = tt.trans_id_file_id(self.conflict_file_id)
+            cparent_tid = tt.get_tree_parent(cp_tid)
+            tt.adjust_path(osutils.basename(self.path), cparent_tid, cp_tid)
+            tt.adjust_path(osutils.basename(self.conflict_path),
+                           parent_tid, p_tid)
+            tt.apply()
+
+
+class UnversionedParent(HandledConflict):
+    """An attempt to version a file whose parent directory is not versioned.
+    Typically, the result of a merge where one tree unversioned the directory
+    and the other added a versioned file to it.
+    """
+
+    typestring = 'unversioned parent'
+
+    format = 'Conflict because %(path)s is not versioned, but has versioned'\
+             ' children.  %(action)s.'
+
+    # FIXME: We silently do nothing to make tests pass, but most probably the
+    # conflict shouldn't exist (the long story is that the conflict is
+    # generated with another one that can be resolved properly) -- vila 091224
+    def action_take_this(self, tree):
+        pass
+
+    def action_take_other(self, tree):
+        pass
+
+
+class MissingParent(HandledConflict):
+    """An attempt to add files to a directory that is not present.
+    Typically, the result of a merge where THIS deleted the directory and
+    the OTHER added a file to it.
+    See also: DeletingParent (same situation, THIS and OTHER reversed)
+    """
+
+    typestring = 'missing parent'
+
+    format = 'Conflict adding files to %(path)s.  %(action)s.'
+
+    def action_take_this(self, tree):
+        tree.remove([self.path], force=True, keep_files=False)
+
+    def action_take_other(self, tree):
+        # just acccept brz proposal
+        pass
+
+
+class DeletingParent(HandledConflict):
+    """An attempt to add files to a directory that is not present.
+    Typically, the result of a merge where one OTHER deleted the directory and
+    the THIS added a file to it.
+    """
+
+    typestring = 'deleting parent'
+
+    format = "Conflict: can't delete %(path)s because it is not empty.  "\
+             "%(action)s."
+
+    # FIXME: It's a bit strange that the default action is not coherent with
+    # MissingParent from the *user* pov.
+
+    def action_take_this(self, tree):
+        # just acccept brz proposal
+        pass
+
+    def action_take_other(self, tree):
+        tree.remove([self.path], force=True, keep_files=False)
+
+
+class NonDirectoryParent(HandledConflict):
+    """An attempt to add files to a directory that is not a directory or
+    an attempt to change the kind of a directory with files.
+    """
+
+    typestring = 'non-directory parent'
+
+    format = "Conflict: %(path)s is not a directory, but has files in it."\
+             "  %(action)s."
+
+    # FIXME: .OTHER should be used instead of .new when the conflict is created
+
+    def action_take_this(self, tree):
+        # FIXME: we should preserve that path when the conflict is generated !
+        if self.path.endswith('.new'):
+            conflict_path = self.path[:-(len('.new'))]
+            tree.remove([self.path], force=True, keep_files=False)
+            tree.add(conflict_path)
+        else:
+            raise NotImplementedError(self.action_take_this)
+
+    def action_take_other(self, tree):
+        # FIXME: we should preserve that path when the conflict is generated !
+        if self.path.endswith('.new'):
+            conflict_path = self.path[:-(len('.new'))]
+            tree.remove([conflict_path], force=True, keep_files=False)
+            tree.rename_one(self.path, conflict_path)
+        else:
+            raise NotImplementedError(self.action_take_other)
+
+
+ctype = {}
+
+
+def register_types(*conflict_types):
+    """Register a Conflict subclass for serialization purposes"""
+    global ctype
+    for conflict_type in conflict_types:
+        ctype[conflict_type.typestring] = conflict_type
+
+
+register_types(ContentsConflict, TextConflict, PathConflict, DuplicateID,
+               DuplicateEntry, ParentLoop, UnversionedParent, MissingParent,
+               DeletingParent, NonDirectoryParent)

=== modified file 'breezy/bzr/dirstate.py'
--- breezy/bzr/dirstate.py	2020-07-18 23:14:00 +0000
+++ breezy/bzr/dirstate.py	2020-08-23 01:05:31 +0000
@@ -243,7 +243,7 @@
     trace,
     urlutils,
     )
-from ..tree import TreeChange
+from .inventorytree import InventoryTreeChange
 
 
 # This is the Windows equivalent of ENOTDIR
@@ -3759,7 +3759,7 @@
                     else:
                         path_u = self.utf8_decode(path)[0]
                 source_kind = DirState._minikind_to_kind[source_minikind]
-                return TreeChange(
+                return InventoryTreeChange(
                     entry[0][2],
                     (old_path_u, path_u),
                     content_change,
@@ -3788,7 +3788,7 @@
                         and stat.S_IEXEC & path_info[3].st_mode)
                 else:
                     target_exec = target_details[3]
-                return TreeChange(
+                return InventoryTreeChange(
                     entry[0][2],
                     (None, self.utf8_decode(path)[0]),
                     True,
@@ -3799,7 +3799,7 @@
                     (None, target_exec)), True
             else:
                 # Its a missing file, report it as such.
-                return TreeChange(
+                return InventoryTreeChange(
                     entry[0][2],
                     (None, self.utf8_decode(path)[0]),
                     False,
@@ -3819,7 +3819,7 @@
                 self.source_index, path_utf8=entry[0][0])[0][2]
             if parent_id == entry[0][2]:
                 parent_id = None
-            return TreeChange(
+            return InventoryTreeChange(
                 entry[0][2],
                 (self.utf8_decode(old_path)[0], None),
                 True,
@@ -3961,7 +3961,7 @@
                 new_executable = bool(
                     stat.S_ISREG(root_dir_info[3].st_mode)
                     and stat.S_IEXEC & root_dir_info[3].st_mode)
-                yield TreeChange(
+                yield InventoryTreeChange(
                     None,
                     (None, current_root_unicode),
                     True,
@@ -4044,7 +4044,7 @@
                                 new_executable = bool(
                                     stat.S_ISREG(current_path_info[3].st_mode)
                                     and stat.S_IEXEC & current_path_info[3].st_mode)
-                                yield TreeChange(
+                                yield InventoryTreeChange(
                                     None,
                                     (None, utf8_decode(current_path_info[0])[0]),
                                     True,
@@ -4180,7 +4180,7 @@
                                 except UnicodeDecodeError:
                                     raise errors.BadFilenameEncoding(
                                         current_path_info[0], osutils._fs_enc)
-                                yield TreeChange(
+                                yield InventoryTreeChange(
                                     None,
                                     (None, relpath_unicode),
                                     True,

=== modified file 'breezy/bzr/inventorytree.py'
--- breezy/bzr/inventorytree.py	2020-07-18 23:14:00 +0000
+++ breezy/bzr/inventorytree.py	2020-08-23 01:05:31 +0000
@@ -67,6 +67,60 @@
     )
 
 
+class InventoryTreeChange(TreeChange):
+
+    __slots__ = TreeChange.__slots__ + ['file_id', 'parent_id']
+
+    def __init__(self, file_id, path, changed_content, versioned, parent_id,
+                 name, kind, executable, copied=False):
+        self.file_id = file_id
+        self.parent_id = parent_id
+        super(InventoryTreeChange, self).__init__(
+            path=path, changed_content=changed_content, versioned=versioned,
+            name=name, kind=kind, executable=executable, copied=copied)
+
+    def __repr__(self):
+        return "%s%r" % (self.__class__.__name__, self._as_tuple())
+
+    def _as_tuple(self):
+        return (self.file_id, self.path, self.changed_content, self.versioned,
+                self.parent_id, self.name, self.kind, self.executable, self.copied)
+
+    def __eq__(self, other):
+        if isinstance(other, TreeChange):
+            return self._as_tuple() == other._as_tuple()
+        if isinstance(other, tuple):
+            return self._as_tuple() == other
+        return False
+
+    def __lt__(self, other):
+        return self._as_tuple() < other._as_tuple()
+
+    def meta_modified(self):
+        if self.versioned == (True, True):
+            return (self.executable[0] != self.executable[1])
+        return False
+
+    def is_reparented(self):
+        return self.parent_id[0] != self.parent_id[1]
+
+    @property
+    def renamed(self):
+        return (
+            not self.copied and
+            None not in self.name and
+            None not in self.parent_id and
+            (self.name[0] != self.name[1] or self.parent_id[0] != self.parent_id[1]))
+
+    def discard_new(self):
+        return self.__class__(
+            self.file_id, (self.path[0], None), self.changed_content,
+            (self.versioned[0], None), (self.parent_id[0], None),
+            (self.name[0], None), (self.kind[0], None),
+            (self.executable[0], None),
+            copied=False)
+
+
 class InventoryTree(Tree):
     """A tree that relies on an inventory for its metadata.
 
@@ -418,6 +472,51 @@
             inv.apply_delta(changes)
             self._write_inventory(inv)
 
+    def has_changes(self, _from_tree=None):
+        """Quickly check that the tree contains at least one commitable change.
+
+        :param _from_tree: tree to compare against to find changes (default to
+            the basis tree and is intended to be used by tests).
+
+        :return: True if a change is found. False otherwise
+        """
+        with self.lock_read():
+            # Check pending merges
+            if len(self.get_parent_ids()) > 1:
+                return True
+            if _from_tree is None:
+                _from_tree = self.basis_tree()
+            changes = self.iter_changes(_from_tree)
+            if self.supports_symlinks():
+                # Fast path for has_changes.
+                try:
+                    change = next(changes)
+                    # Exclude root (talk about black magic... --vila 20090629)
+                    if change.parent_id == (None, None):
+                        change = next(changes)
+                    return True
+                except StopIteration:
+                    # No changes
+                    return False
+            else:
+                # Slow path for has_changes.
+                # Handle platforms that do not support symlinks in the
+                # conditional below. This is slower than the try/except
+                # approach below that but we don't have a choice as we
+                # need to be sure that all symlinks are removed from the
+                # entire changeset. This is because in platforms that
+                # do not support symlinks, they show up as None in the
+                # working copy as compared to the repository.
+                # Also, exclude root as mention in the above fast path.
+                changes = filter(
+                    lambda c: c[6][0] != 'symlink' and c[4] != (None, None),
+                    changes)
+                try:
+                    next(iter(changes))
+                except StopIteration:
+                    return False
+                return True
+
     def _fix_case_of_inventory_path(self, path):
         """If our tree isn't case sensitive, return the canonical path"""
         if not self.case_sensitive:
@@ -906,27 +1005,25 @@
         if top_id is None:
             pending = []
         else:
-            pending = [(prefix, '', _directory, None, top_id, None)]
+            pending = [(prefix, top_id)]
         while pending:
             dirblock = []
-            currentdir = pending.pop()
-            # 0 - relpath, 1- basename, 2- kind, 3- stat, id, v-kind
-            if currentdir[0]:
-                relroot = currentdir[0] + '/'
+            root, file_id = pending.pop()
+            if root:
+                relroot = root + '/'
             else:
                 relroot = ""
             # FIXME: stash the node in pending
-            entry = inv.get_entry(currentdir[4])
+            entry = inv.get_entry(file_id)
+            subdirs = []
             for name, child in entry.sorted_children():
                 toppath = relroot + name
-                dirblock.append((toppath, name, child.kind, None,
-                                 child.file_id, child.kind
-                                 ))
-            yield (currentdir[0], entry.file_id), dirblock
+                dirblock.append((toppath, name, child.kind, None, child.kind))
+                if child.kind == _directory:
+                    subdirs.append((toppath, child.file_id))
+            yield root, dirblock
             # push the user specified dirs from dirblock
-            for dir in reversed(dirblock):
-                if dir[2] == _directory:
-                    pending.append(dir)
+            pending.extend(reversed(subdirs))
 
     def iter_files_bytes(self, desired_files):
         """See Tree.iter_files_bytes.
@@ -1047,7 +1144,7 @@
             changes = True
         else:
             changes = False
-        return TreeChange(
+        return InventoryTreeChange(
             file_id, (source_path, target_path), changed_content,
             versioned, parent, name, kind, executable), changes
 
@@ -1141,7 +1238,7 @@
                 target_kind, target_executable, target_stat = \
                     self.target._comparison_data(
                         fake_entry, unversioned_path[1])
-                yield TreeChange(
+                yield InventoryTreeChange(
                     None, (None, unversioned_path[1]), True, (False, False),
                     (None, None),
                     (None, unversioned_path[0][-1]),
@@ -1178,7 +1275,7 @@
             unversioned_path = all_unversioned.popleft()
             to_kind, to_executable, to_stat = \
                 self.target._comparison_data(fake_entry, unversioned_path[1])
-            yield TreeChange(
+            yield InventoryTreeChange(
                 None, (None, unversioned_path[1]), True, (False, False),
                 (None, None),
                 (None, unversioned_path[0][-1]),
@@ -1204,7 +1301,7 @@
             changed_content = from_kind is not None
             # the parent's path is necessarily known at this point.
             changed_file_ids.append(file_id)
-            yield TreeChange(
+            yield InventoryTreeChange(
                 file_id, (path, to_path), changed_content, versioned, parent,
                 name, kind, executable)
         changed_file_ids = set(changed_file_ids)
@@ -1390,7 +1487,7 @@
         # FIXME: nested tree support
         for result in self.target.root_inventory.iter_changes(
                 self.source.root_inventory):
-            result = TreeChange(*result)
+            result = InventoryTreeChange(*result)
             if specific_file_ids is not None:
                 if result.file_id not in specific_file_ids:
                     # A change from the whole tree that we don't want to show yet.
@@ -1417,7 +1514,7 @@
                         entry.file_id not in specific_file_ids):
                     continue
                 if entry.file_id not in changed_file_ids:
-                    yield TreeChange(
+                    yield InventoryTreeChange(
                         entry.file_id,
                         (relpath, relpath),  # Not renamed
                         False,  # Not modified

=== modified file 'breezy/bzr/tests/__init__.py'
--- breezy/bzr/tests/__init__.py	2020-06-30 00:19:29 +0000
+++ breezy/bzr/tests/__init__.py	2020-08-23 01:05:31 +0000
@@ -63,6 +63,7 @@
         'test_bzrdir',
         'test_chk_map',
         'test_chk_serializer',
+        'test_conflicts',
         'test_generate_ids',
         'test_groupcompress',
         'test_index',

=== added file 'breezy/bzr/tests/test_conflicts.py'
--- breezy/bzr/tests/test_conflicts.py	1970-01-01 00:00:00 +0000
+++ breezy/bzr/tests/test_conflicts.py	2020-08-23 01:05:31 +0000
@@ -0,0 +1,133 @@
+# Copyright (C) 2005-2011 Canonical Ltd
+# Copyright (C) 2018-2020 Breezy Developers
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
+import os
+
+from ...conflicts import resolve
+from ... import (
+    tests,
+    )
+
+from ...tests import (
+    scenarios,
+    )
+from ...tests.test_conflicts import vary_by_conflicts
+
+
+from .. import conflicts as bzr_conflicts
+
+
+load_tests = scenarios.load_tests_apply_scenarios
+
+
+class TestPerConflict(tests.TestCase):
+
+    scenarios = scenarios.multiply_scenarios(vary_by_conflicts())
+
+    def test_stringification(self):
+        text = str(self.conflict)
+        self.assertContainsString(text, self.conflict.path)
+        self.assertContainsString(text.lower(), "conflict")
+        self.assertContainsString(repr(self.conflict),
+                                  self.conflict.__class__.__name__)
+
+    def test_stanza_roundtrip(self):
+        p = self.conflict
+        o = bzr_conflicts.Conflict.factory(**p.as_stanza().as_dict())
+        self.assertEqual(o, p)
+
+        self.assertIsInstance(o.path, str)
+
+        if o.file_id is not None:
+            self.assertIsInstance(o.file_id, bytes)
+
+        conflict_path = getattr(o, 'conflict_path', None)
+        if conflict_path is not None:
+            self.assertIsInstance(conflict_path, str)
+
+        conflict_file_id = getattr(o, 'conflict_file_id', None)
+        if conflict_file_id is not None:
+            self.assertIsInstance(conflict_file_id, bytes)
+
+    def test_stanzification(self):
+        stanza = self.conflict.as_stanza()
+        if 'file_id' in stanza:
+            # In Stanza form, the file_id has to be unicode.
+            self.assertStartsWith(stanza['file_id'], u'\xeed')
+        self.assertStartsWith(stanza['path'], u'p\xe5th')
+        if 'conflict_path' in stanza:
+            self.assertStartsWith(stanza['conflict_path'], u'p\xe5th')
+        if 'conflict_file_id' in stanza:
+            self.assertStartsWith(stanza['conflict_file_id'], u'\xeed')
+
+
+class TestConflicts(tests.TestCaseWithTransport):
+
+    def test_resolve_conflict_dir(self):
+        tree = self.make_branch_and_tree('.')
+        self.build_tree_contents([('hello', b'hello world4'),
+                                  ('hello.THIS', b'hello world2'),
+                                  ('hello.BASE', b'hello world1'),
+                                  ])
+        os.mkdir('hello.OTHER')
+        tree.add('hello', b'q')
+        l = bzr_conflicts.ConflictList([bzr_conflicts.TextConflict('hello')])
+        l.remove_files(tree)
+
+    def test_select_conflicts(self):
+        tree = self.make_branch_and_tree('.')
+        clist = bzr_conflicts.ConflictList
+
+        def check_select(not_selected, selected, paths, **kwargs):
+            self.assertEqual(
+                (not_selected, selected),
+                tree_conflicts.select_conflicts(tree, paths, **kwargs))
+
+        foo = bzr_conflicts.ContentsConflict('foo')
+        bar = bzr_conflicts.ContentsConflict('bar')
+        tree_conflicts = clist([foo, bar])
+
+        check_select(clist([bar]), clist([foo]), ['foo'])
+        check_select(clist(), tree_conflicts,
+                     [''], ignore_misses=True, recurse=True)
+
+        foobaz = bzr_conflicts.ContentsConflict('foo/baz')
+        tree_conflicts = clist([foobaz, bar])
+
+        check_select(clist([bar]), clist([foobaz]),
+                     ['foo'], ignore_misses=True, recurse=True)
+
+        qux = bzr_conflicts.PathConflict('qux', 'foo/baz')
+        tree_conflicts = clist([qux])
+
+        check_select(clist(), tree_conflicts,
+                     ['foo'], ignore_misses=True, recurse=True)
+        check_select(tree_conflicts, clist(), ['foo'], ignore_misses=True)
+
+    def test_resolve_conflicts_recursive(self):
+        tree = self.make_branch_and_tree('.')
+        self.build_tree(['dir/', 'dir/hello'])
+        tree.add(['dir', 'dir/hello'])
+
+        dirhello = [bzr_conflicts.TextConflict('dir/hello')]
+        tree.set_conflicts(dirhello)
+
+        resolve(tree, ['dir'], recursive=False, ignore_misses=True)
+        self.assertEqual(dirhello, tree.conflicts())
+
+        resolve(tree, ['dir'], recursive=True, ignore_misses=True)
+        self.assertEqual(bzr_conflicts.ConflictList([]), tree.conflicts())

=== modified file 'breezy/bzr/transform.py'
--- breezy/bzr/transform.py	2020-07-20 02:02:23 +0000
+++ breezy/bzr/transform.py	2020-08-23 01:05:31 +0000
@@ -24,6 +24,7 @@
 
 from .. import (
     annotate,
+    conflicts,
     errors,
     lock,
     multiparent,
@@ -52,7 +53,8 @@
     MalformedTransform,
     PreviewTree,
     )
-from ..tree import TreeChange
+from .conflicts import Conflict
+
 from . import (
     inventory,
     inventorytree,
@@ -108,7 +110,7 @@
 
     def create_path(self, name, parent):
         """Assign a transaction id to a new path"""
-        trans_id = self._assign_id()
+        trans_id = self.assign_id()
         unique_add(self._new_name, trans_id, name)
         unique_add(self._new_parent, trans_id, parent)
         return trans_id
@@ -223,7 +225,7 @@
                 if file_id in self._non_present_ids:
                     return self._non_present_ids[file_id]
                 else:
-                    trans_id = self._assign_id()
+                    trans_id = self.assign_id()
                     self._non_present_ids[file_id] = trans_id
                     return trans_id
             else:
@@ -296,7 +298,7 @@
             if value == trans_id:
                 return key
 
-    def find_conflicts(self):
+    def find_raw_conflicts(self):
         """Find any violations of inventory or filesystem invariants"""
         if self._done is True:
             raise ReusingTransform()
@@ -315,7 +317,7 @@
         return conflicts
 
     def _check_malformed(self):
-        conflicts = self.find_conflicts()
+        conflicts = self.find_raw_conflicts()
         if len(conflicts) != 0:
             raise MalformedTransform(conflicts=conflicts)
 
@@ -703,7 +705,7 @@
         """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.
+        conflicts (as reported by TreeTransform.find_raw_conflicts()) are present.
 
         This reads the Transform, but only reproduces changes involving a
         file_id.  Files that are not versioned in either of the FROM or TO
@@ -755,7 +757,7 @@
                     and from_executable == to_executable):
                 continue
             results.append(
-                TreeChange(
+                inventorytree.InventoryTreeChange(
                     file_id, (from_path, to_path), modified,
                     (from_versioned, to_versioned),
                     (from_parent, to_parent),
@@ -1010,6 +1012,100 @@
         """
         raise NotImplementedError(self.apply)
 
+    def cook_conflicts(self, raw_conflicts):
+        """Generate a list of cooked conflicts, sorted by file path"""
+        content_conflict_file_ids = set()
+        cooked_conflicts = list(iter_cook_conflicts(raw_conflicts, self))
+        for c in cooked_conflicts:
+            if c.typestring == 'contents conflict':
+                content_conflict_file_ids.add(c.file_id)
+        # We want to get rid of path conflicts when a corresponding contents
+        # conflict exists. This can occur when one branch deletes a file while
+        # the other renames *and* modifies it. In this case, the content
+        # conflict is enough.
+        cooked_conflicts = [
+            c for c in cooked_conflicts
+            if c.typestring != 'path conflict' or
+            c.file_id not in content_conflict_file_ids]
+        return sorted(cooked_conflicts, key=Conflict.sort_key)
+
+
+def cook_path_conflict(
+        tt, fp, conflict_type, trans_id, file_id, this_parent, this_name,
+        other_parent, other_name):
+    if this_parent is None or this_name is None:
+        this_path = '<deleted>'
+    else:
+        parent_path = fp.get_path(tt.trans_id_file_id(this_parent))
+        this_path = osutils.pathjoin(parent_path, this_name)
+    if other_parent is None or other_name is None:
+        other_path = '<deleted>'
+    else:
+        try:
+            parent_path = fp.get_path(tt.trans_id_file_id(other_parent))
+        except NoFinalPath:
+            # The other entry was in a path that doesn't exist in our tree.
+            # Put it in the root.
+            parent_path = ''
+        other_path = osutils.pathjoin(parent_path, other_name)
+    return Conflict.factory(
+        conflict_type, path=this_path,
+        conflict_path=other_path,
+        file_id=file_id)
+
+
+def cook_content_conflict(tt, fp, conflict_type, trans_ids):
+    for trans_id in trans_ids:
+        file_id = tt.final_file_id(trans_id)
+        if file_id is not None:
+            # Ok we found the relevant file-id
+            break
+    path = fp.get_path(trans_id)
+    for suffix in ('.BASE', '.THIS', '.OTHER'):
+        if path.endswith(suffix):
+            # Here is the raw path
+            path = path[:-len(suffix)]
+            break
+    return Conflict.factory(conflict_type, path=path, file_id=file_id)
+
+
+def cook_text_conflict(tt, fp, conflict_type, trans_id):
+    path = fp.get_path(trans_id)
+    file_id = tt.final_file_id(trans_id)
+    return Conflict.factory(conflict_type, path=path, file_id=file_id)
+
+
+CONFLICT_COOKERS = {
+    'path conflict': cook_path_conflict,
+    'text conflict': cook_text_conflict,
+    'contents conflict': cook_content_conflict,
+}
+
+def iter_cook_conflicts(raw_conflicts, tt):
+    fp = FinalPaths(tt)
+    for conflict in raw_conflicts:
+        c_type = conflict[0]
+        try:
+            cooker = CONFLICT_COOKERS[c_type]
+        except KeyError:
+            action = conflict[1]
+            modified_path = fp.get_path(conflict[2])
+            modified_id = tt.final_file_id(conflict[2])
+            if len(conflict) == 3:
+                yield Conflict.factory(
+                    c_type, action=action, path=modified_path, file_id=modified_id)
+
+            else:
+                conflicting_path = fp.get_path(conflict[3])
+                conflicting_id = tt.final_file_id(conflict[3])
+                yield Conflict.factory(
+                    c_type, action=action, path=modified_path,
+                    file_id=modified_id,
+                    conflict_path=conflicting_path,
+                    conflict_file_id=conflicting_id)
+        else:
+            yield cooker(tt, fp, *conflict)
+
 
 class DiskTreeTransform(TreeTransformBase):
     """Tree transform storing its contents on disk."""
@@ -1497,8 +1593,8 @@
                 conflicts.append(('duplicate id', old_trans_id, trans_id))
         return conflicts
 
-    def find_conflicts(self):
-        conflicts = super(InventoryTreeTransform, self).find_conflicts()
+    def find_raw_conflicts(self):
+        conflicts = super(InventoryTreeTransform, self).find_raw_conflicts()
         conflicts.extend(self._duplicate_ids())
         return conflicts
 
@@ -1816,6 +1912,9 @@
         self._iter_changes_cache = {
             c.file_id: c for c in self._transform.iter_changes()}
 
+    def supports_setting_file_ids(self):
+        return True
+
     def supports_tree_reference(self):
         # TODO(jelmer): Support tree references in PreviewTree.
         # return self._transform._tree.supports_tree_reference()
@@ -2028,6 +2127,7 @@
             limbo_name = tt._limbo_name(trans_id)
             if trans_id in tt._new_reference_revision:
                 kind = 'tree-reference'
+                link_or_sha1 = tt._new_reference_revision
             if kind == 'file':
                 statval = os.lstat(limbo_name)
                 size = statval.st_size
@@ -2071,21 +2171,28 @@
         file_id = self.path2id(path)
         changes = self._iter_changes_cache.get(file_id)
         if changes is None:
-            get_old = True
+            if file_id is None:
+                old_path = None
+            else:
+                old_path = self._transform._tree.id2path(file_id)
         else:
-            changed_content, versioned, kind = (
-                changes.changed_content, changes.versioned, changes.kind)
-            if kind[1] is None:
+            if changes.kind[1] is None:
                 return None
-            get_old = (kind[0] == 'file' and versioned[0])
-        if get_old:
+            if changes.kind[0] == 'file' and changes.versioned[0]:
+                old_path = changes.path[0]
+            else:
+                old_path = None
+        if old_path is not None:
             old_annotation = self._transform._tree.annotate_iter(
-                path, default_revision=default_revision)
+                old_path, default_revision=default_revision)
         else:
             old_annotation = []
         if changes is None:
-            return old_annotation
-        if not changed_content:
+            if old_path is None:
+                return None
+            else:
+                return old_annotation
+        if not changes.changed_content:
             return old_annotation
         # TODO: This is doing something similar to what WT.annotate_iter is
         #       doing, however it fails slightly because it doesn't know what
@@ -2095,7 +2202,7 @@
         #       It would be nice to be able to use the new Annotator based
         #       approach, as well.
         return annotate.reannotate([old_annotation],
-                                   self.get_file(path).readlines(),
+                                   self.get_file_lines(path),
                                    default_revision)
 
     def walkdirs(self, prefix=''):
@@ -2117,14 +2224,14 @@
                 else:
                     kind = 'unknown'
                     versioned_kind = self._transform._tree.stored_kind(
-                        self._transform._tree.id2path(file_id))
+                        path_from_root)
                 if versioned_kind == 'directory':
                     subdirs.append(child_id)
                 children.append((path_from_root, basename, kind, None,
-                                 file_id, versioned_kind))
+                                 versioned_kind))
             children.sort()
             if parent_path.startswith(prefix):
-                yield (parent_path, parent_file_id), children
+                yield parent_path, children
             pending.extend(sorted(subdirs, key=self._final_paths.get_path,
                                   reverse=True))
 

=== modified file 'breezy/bzr/vf_repository.py'
--- breezy/bzr/vf_repository.py	2020-07-18 23:14:00 +0000
+++ breezy/bzr/vf_repository.py	2020-08-23 01:05:31 +0000
@@ -80,7 +80,7 @@
 from ..trace import (
     mutter
     )
-from ..tree import TreeChange
+from .inventorytree import InventoryTreeChange
 
 
 class VersionedFileRepositoryFormat(RepositoryFormat):
@@ -399,7 +399,7 @@
                 # by the user. So we discard this change.
                 pass
             else:
-                change = TreeChange(
+                change = InventoryTreeChange(
                     file_id,
                     (basis_inv.id2path(file_id), tree.id2path(file_id)),
                     False, (True, True),

=== modified file 'breezy/bzr/workingtree.py'
--- breezy/bzr/workingtree.py	2020-07-18 23:14:00 +0000
+++ breezy/bzr/workingtree.py	2020-08-23 01:05:31 +0000
@@ -60,6 +60,7 @@
     rio as _mod_rio,
     )
 from breezy.bzr import (
+    conflicts as _mod_bzr_conflicts,
     inventory,
     serializer,
     xml5,
@@ -403,8 +404,8 @@
         def recurse_directory_to_add_files(directory):
             # Recurse directory and add all files
             # so we can check if they have changed.
-            for parent_info, file_infos in self.walkdirs(directory):
-                for relpath, basename, kind, lstat, fileid, kind in file_infos:
+            for parent_path, file_infos in self.walkdirs(directory):
+                for relpath, basename, kind, lstat, kind in file_infos:
                     # Is it versioned or ignored?
                     if self.is_versioned(relpath):
                         # Add nested content for deletion.
@@ -573,23 +574,24 @@
         return xml7.serializer_v7.write_inventory_to_lines(inventory)
 
     def set_conflicts(self, conflicts):
+        conflict_list = _mod_bzr_conflicts.ConflictList(conflicts)
         with self.lock_tree_write():
-            self._put_rio('conflicts', conflicts.to_stanzas(),
+            self._put_rio('conflicts', conflict_list.to_stanzas(),
                           CONFLICT_HEADER_1)
 
     def add_conflicts(self, new_conflicts):
         with self.lock_tree_write():
             conflict_set = set(self.conflicts())
             conflict_set.update(set(list(new_conflicts)))
-            self.set_conflicts(_mod_conflicts.ConflictList(
-                sorted(conflict_set, key=_mod_conflicts.Conflict.sort_key)))
+            self.set_conflicts(
+                sorted(conflict_set, key=_mod_bzr_conflicts.Conflict.sort_key))
 
     def conflicts(self):
         with self.lock_read():
             try:
                 confile = self._transport.get('conflicts')
             except errors.NoSuchFile:
-                return _mod_conflicts.ConflictList()
+                return _mod_bzr_conflicts.ConflictList()
             try:
                 try:
                     if next(confile) != CONFLICT_HEADER_1 + b'\n':
@@ -597,7 +599,7 @@
                 except StopIteration:
                     raise errors.ConflictFormatError()
                 reader = _mod_rio.RioReader(confile)
-                return _mod_conflicts.ConflictList.from_stanzas(reader)
+                return _mod_bzr_conflicts.ConflictList.from_stanzas(reader)
             finally:
                 confile.close()
 
@@ -1562,8 +1564,8 @@
         """Walk the directories of this tree.
 
         returns a generator which yields items in the form:
-                ((curren_directory_path, fileid),
-                 [(file1_path, file1_name, file1_kind, (lstat), file1_id,
+                (current_directory_path,
+                 [(file1_path, file1_name, file1_kind, (lstat),
                    file1_kind), ... ])
 
         This API returns a generator, which is only valid during the current
@@ -1626,20 +1628,20 @@
 
             if direction > 0:
                 # disk is before inventory - unknown
-                dirblock = [(relpath, basename, kind, stat, None, None) for
+                dirblock = [(relpath, basename, kind, stat, None) for
                             relpath, basename, kind, stat, top_path in
                             cur_disk_dir_content]
-                yield (cur_disk_dir_relpath, None), dirblock
+                yield cur_disk_dir_relpath, dirblock
                 try:
                     current_disk = next(disk_iterator)
                 except StopIteration:
                     disk_finished = True
             elif direction < 0:
                 # inventory is before disk - missing.
-                dirblock = [(relpath, basename, 'unknown', None, fileid, kind)
+                dirblock = [(relpath, basename, 'unknown', None, kind)
                             for relpath, basename, dkind, stat, fileid, kind in
                             current_inv[1]]
-                yield (current_inv[0][0], current_inv[0][1]), dirblock
+                yield current_inv[0][0], dirblock
                 try:
                     current_inv = next(inventory_iterator)
                 except StopIteration:
@@ -1657,23 +1659,20 @@
                         # versioned, present file
                         dirblock.append((inv_row[0],
                                          inv_row[1], disk_row[2],
-                                         disk_row[3], inv_row[4],
-                                         inv_row[5]))
+                                         disk_row[3], inv_row[5]))
                     elif len(path_elements[0]) == 5:
                         # unknown disk file
                         dirblock.append(
                             (path_elements[0][0], path_elements[0][1],
-                             path_elements[0][2], path_elements[0][3], None,
-                             None))
+                             path_elements[0][2], path_elements[0][3], None))
                     elif len(path_elements[0]) == 6:
                         # versioned, absent file.
                         dirblock.append(
                             (path_elements[0][0], path_elements[0][1],
-                             'unknown', None, path_elements[0][4],
-                             path_elements[0][5]))
+                             'unknown', None, path_elements[0][5]))
                     else:
                         raise NotImplementedError('unreachable code')
-                yield current_inv[0], dirblock
+                yield current_inv[0][0], dirblock
                 try:
                     current_inv = next(inventory_iterator)
                 except StopIteration:
@@ -1818,6 +1817,52 @@
             self.path2id(path),
             path, possible_transports=possible_transports)
 
+    def has_changes(self, _from_tree=None):
+        """Quickly check that the tree contains at least one commitable change.
+
+        :param _from_tree: tree to compare against to find changes (default to
+            the basis tree and is intended to be used by tests).
+
+        :return: True if a change is found. False otherwise
+        """
+        with self.lock_read():
+            # Check pending merges
+            if len(self.get_parent_ids()) > 1:
+                return True
+            if _from_tree is None:
+                _from_tree = self.basis_tree()
+            changes = self.iter_changes(_from_tree)
+            if self.supports_symlinks():
+                # Fast path for has_changes.
+                try:
+                    change = next(changes)
+                    # Exclude root (talk about black magic... --vila 20090629)
+                    if change.parent_id == (None, None):
+                        change = next(changes)
+                    return True
+                except StopIteration:
+                    # No changes
+                    return False
+            else:
+                # Slow path for has_changes.
+                # Handle platforms that do not support symlinks in the
+                # conditional below. This is slower than the try/except
+                # approach below that but we don't have a choice as we
+                # need to be sure that all symlinks are removed from the
+                # entire changeset. This is because in platforms that
+                # do not support symlinks, they show up as None in the
+                # working copy as compared to the repository.
+                # Also, exclude root as mention in the above fast path.
+                changes = filter(
+                    lambda c: c[6][0] != 'symlink' and c[4] != (None, None),
+                    changes)
+                try:
+                    next(iter(changes))
+                except StopIteration:
+                    return False
+                return True
+
+
 
 class WorkingTreeFormatMetaDir(bzrdir.BzrFormat, WorkingTreeFormat):
     """Base class for working trees that live in bzr meta directories."""

=== modified file 'breezy/bzr/workingtree_4.py'
--- breezy/bzr/workingtree_4.py	2020-07-18 23:14:00 +0000
+++ breezy/bzr/workingtree_4.py	2020-08-23 01:05:31 +0000
@@ -465,7 +465,13 @@
 
     def get_reference_revision(self, path):
         # referenced tree's revision is whatever's currently there
-        return self.get_nested_tree(path).last_revision()
+        try:
+            return self.get_nested_tree(path).last_revision()
+        except errors.NotBranchError:
+            entry = self._get_entry(path=path)
+            if entry == (None, None):
+                return False
+            return entry[1][0][1]
 
     def get_nested_tree(self, path):
         return WorkingTree.open(self.abspath(path))
@@ -2157,16 +2163,15 @@
                 relroot = ""
             # FIXME: stash the node in pending
             entry = inv.get_entry(file_id)
+            subdirs = []
             for name, child in entry.sorted_children():
                 toppath = relroot + name
-                dirblock.append((toppath, name, child.kind, None,
-                                 child.file_id, child.kind
-                                 ))
-            yield (relpath, entry.file_id), dirblock
+                dirblock.append((toppath, name, child.kind, None, child.kind))
+                if child.kind == _directory:
+                    subdirs.append((toppath, child.file_id))
+            yield relpath, dirblock
             # push the user specified dirs from dirblock
-            for dir in reversed(dirblock):
-                if dir[2] == _directory:
-                    pending.append((dir[0], dir[4]))
+            pending.extend(reversed(subdirs))
 
 
 class InterDirStateTree(InterInventoryTree):

=== modified file 'breezy/commit.py'
--- breezy/commit.py	2020-06-19 21:26:53 +0000
+++ breezy/commit.py	2020-08-23 01:05:31 +0000
@@ -67,7 +67,6 @@
                       minimum_path_selection,
                       )
 from .trace import mutter, note, is_quiet
-from .tree import TreeChange
 from .urlutils import unescape_for_display
 from .i18n import gettext
 

=== modified file 'breezy/conflicts.py'
--- breezy/conflicts.py	2020-07-18 23:14:00 +0000
+++ breezy/conflicts.py	2020-08-23 01:05:31 +0000
@@ -17,18 +17,14 @@
 # TODO: 'brz resolve' should accept a directory name and work from that
 # point down
 
+import errno
 import os
 import re
 
 from .lazy_import import lazy_import
 lazy_import(globals(), """
-import errno
 
 from breezy import (
-    osutils,
-    rio,
-    trace,
-    transform,
     workingtree,
     )
 from breezy.i18n import gettext, ngettext
@@ -38,13 +34,12 @@
     errors,
     commands,
     option,
+    osutils,
     registry,
+    trace,
     )
 
 
-CONFLICT_SUFFIXES = ('.THIS', '.BASE', '.OTHER')
-
-
 class cmd_conflicts(commands.Command):
     __doc__ = """List files with conflicts.
 
@@ -127,7 +122,7 @@
         if all:
             if file_list:
                 raise errors.CommandError(gettext("If --all is specified,"
-                                                     " no FILE may be provided"))
+                                                  " no FILE may be provided"))
             if directory is None:
                 directory = u'.'
             tree = workingtree.WorkingTree.open_containing(directory)[0]
@@ -182,14 +177,14 @@
         tree_conflicts = tree.conflicts()
         nb_conflicts_before = len(tree_conflicts)
         if paths is None:
-            new_conflicts = ConflictList()
+            new_conflicts = []
             to_process = tree_conflicts
         else:
             new_conflicts, to_process = tree_conflicts.select_conflicts(
                 tree, paths, ignore_misses, recursive)
         for conflict in to_process:
             try:
-                conflict._do(action, tree)
+                conflict.do(action, tree)
                 conflict.cleanup(tree)
             except NotImplementedError:
                 new_conflicts.append(conflict)
@@ -235,8 +230,6 @@
     """List of conflicts.
 
     Typically obtained from WorkingTree.conflicts()
-
-    Can be instantiated from stanzas or from Conflict subclasses.
     """
 
     def __init__(self, conflicts=None):
@@ -270,19 +263,6 @@
     def __repr__(self):
         return "ConflictList(%r)" % self.__list
 
-    @staticmethod
-    def from_stanzas(stanzas):
-        """Produce a new ConflictList from an iterable of stanzas"""
-        conflicts = ConflictList()
-        for stanza in stanzas:
-            conflicts.append(Conflict.factory(**stanza.as_dict()))
-        return conflicts
-
-    def to_stanzas(self):
-        """Generator of stanzas"""
-        for conflict in self:
-            yield conflict.as_stanza()
-
     def to_strings(self):
         """Generate strings for the provided conflicts"""
         for conflict in self:
@@ -299,43 +279,23 @@
                          recurse=False):
         """Select the conflicts associated with paths in a tree.
 
-        File-ids are also used for this.
         :return: a pair of ConflictLists: (not_selected, selected)
         """
         path_set = set(paths)
-        ids = {}
         selected_paths = set()
         new_conflicts = ConflictList()
         selected_conflicts = ConflictList()
-        for path in paths:
-            file_id = tree.path2id(path)
-            if file_id is not None:
-                ids[file_id] = path
 
         for conflict in self:
             selected = False
-            for key in ('path', 'conflict_path'):
-                cpath = getattr(conflict, key, None)
-                if cpath is None:
-                    continue
-                if cpath in path_set:
+            if conflict.path in path_set:
+                selected = True
+                selected_paths.add(conflict.path)
+            if recurse:
+                if osutils.is_inside_any(path_set, conflict.path):
                     selected = True
-                    selected_paths.add(cpath)
-                if recurse:
-                    if osutils.is_inside_any(path_set, cpath):
-                        selected = True
-                        selected_paths.add(cpath)
+                    selected_paths.add(conflict.path)
 
-            for key in ('file_id', 'conflict_file_id'):
-                cfile_id = getattr(conflict, key, None)
-                if cfile_id is None:
-                    continue
-                try:
-                    cpath = ids[cfile_id]
-                except KeyError:
-                    continue
-                selected = True
-                selected_paths.add(cpath)
             if selected:
                 selected_conflicts.append(conflict)
             else:
@@ -350,84 +310,12 @@
 
 
 class Conflict(object):
-    """Base class for all types of conflict"""
-
-    # FIXME: cleanup should take care of that ? -- vila 091229
-    has_files = False
-
-    def __init__(self, path, file_id=None):
+    """Base class for conflicts."""
+
+    typestring = None
+
+    def __init__(self, path):
         self.path = path
-        # the factory blindly transfers the Stanza values to __init__ and
-        # Stanza is purely a Unicode api.
-        if isinstance(file_id, str):
-            file_id = cache_utf8.encode(file_id)
-        self.file_id = file_id
-
-    def as_stanza(self):
-        s = rio.Stanza(type=self.typestring, path=self.path)
-        if self.file_id is not None:
-            # Stanza requires Unicode apis
-            s.add('file_id', self.file_id.decode('utf8'))
-        return s
-
-    def _cmp_list(self):
-        return [type(self), self.path, self.file_id]
-
-    def __cmp__(self, other):
-        if getattr(other, "_cmp_list", None) is None:
-            return -1
-        x = self._cmp_list()
-        y = other._cmp_list()
-        return (x > y) - (x < y)
-
-    def __hash__(self):
-        return hash((type(self), self.path, self.file_id))
-
-    def __eq__(self, other):
-        return self.__cmp__(other) == 0
-
-    def __ne__(self, other):
-        return not self.__eq__(other)
-
-    def __unicode__(self):
-        return self.describe()
-
-    def __str__(self):
-        return self.describe()
-
-    def describe(self):
-        return self.format % self.__dict__
-
-    def __repr__(self):
-        rdict = dict(self.__dict__)
-        rdict['class'] = self.__class__.__name__
-        return self.rformat % rdict
-
-    @staticmethod
-    def factory(type, **kwargs):
-        global ctype
-        return ctype[type](**kwargs)
-
-    @staticmethod
-    def sort_key(conflict):
-        if conflict.path is not None:
-            return conflict.path, conflict.typestring
-        elif getattr(conflict, "conflict_path", None) is not None:
-            return conflict.conflict_path, conflict.typestring
-        else:
-            return None, conflict.typestring
-
-    def _do(self, action, tree):
-        """Apply the specified action to the conflict.
-
-        :param action: The method name to call.
-
-        :param tree: The tree passed as a parameter to the method.
-        """
-        meth = getattr(self, 'action_%s' % action, None)
-        if meth is None:
-            raise NotImplementedError(self.__class__.__name__ + '.' + action)
-        meth(tree)
 
     def associated_filenames(self):
         """The names of the files generated to help resolve the conflict."""
@@ -441,472 +329,15 @@
                 if e.errno != errno.ENOENT:
                     raise
 
-    def action_auto(self, tree):
-        raise NotImplementedError(self.action_auto)
-
-    def action_done(self, tree):
-        """Mark the conflict as solved once it has been handled."""
-        # This method does nothing but simplifies the design of upper levels.
-        pass
-
-    def action_take_this(self, tree):
-        raise NotImplementedError(self.action_take_this)
-
-    def action_take_other(self, tree):
-        raise NotImplementedError(self.action_take_other)
-
-    def _resolve_with_cleanups(self, tree, *args, **kwargs):
-        with tree.transform() as tt:
-            self._resolve(tt, *args, **kwargs)
-
-
-class PathConflict(Conflict):
-    """A conflict was encountered merging file paths"""
-
-    typestring = 'path conflict'
-
-    format = 'Path conflict: %(path)s / %(conflict_path)s'
-
-    rformat = '%(class)s(%(path)r, %(conflict_path)r, %(file_id)r)'
-
-    def __init__(self, path, conflict_path=None, file_id=None):
-        Conflict.__init__(self, path, file_id)
-        self.conflict_path = conflict_path
-
-    def as_stanza(self):
-        s = Conflict.as_stanza(self)
-        if self.conflict_path is not None:
-            s.add('conflict_path', self.conflict_path)
-        return s
-
-    def associated_filenames(self):
-        # No additional files have been generated here
-        return []
-
-    def _resolve(self, tt, file_id, path, winner):
-        """Resolve the conflict.
-
-        :param tt: The TreeTransform where the conflict is resolved.
-        :param file_id: The retained file id.
-        :param path: The retained path.
-        :param winner: 'this' or 'other' indicates which side is the winner.
-        """
-        path_to_create = None
-        if winner == 'this':
-            if self.path == '<deleted>':
-                return  # Nothing to do
-            if self.conflict_path == '<deleted>':
-                path_to_create = self.path
-                revid = tt._tree.get_parent_ids()[0]
-        elif winner == 'other':
-            if self.conflict_path == '<deleted>':
-                return  # Nothing to do
-            if self.path == '<deleted>':
-                path_to_create = self.conflict_path
-                # FIXME: If there are more than two parents we may need to
-                # iterate. Taking the last parent is the safer bet in the mean
-                # time. -- vila 20100309
-                revid = tt._tree.get_parent_ids()[-1]
-        else:
-            # Programmer error
-            raise AssertionError('bad winner: %r' % (winner,))
-        if path_to_create is not None:
-            tid = tt.trans_id_tree_path(path_to_create)
-            tree = self._revision_tree(tt._tree, revid)
-            transform.create_from_tree(
-                tt, tid, tree, tree.id2path(file_id))
-            tt.version_file(tid, file_id=file_id)
-        else:
-            tid = tt.trans_id_file_id(file_id)
-        # Adjust the path for the retained file id
-        parent_tid = tt.get_tree_parent(tid)
-        tt.adjust_path(osutils.basename(path), parent_tid, tid)
-        tt.apply()
-
-    def _revision_tree(self, tree, revid):
-        return tree.branch.repository.revision_tree(revid)
-
-    def _infer_file_id(self, tree):
-        # Prior to bug #531967, file_id wasn't always set, there may still be
-        # conflict files in the wild so we need to cope with them
-        # Establish which path we should use to find back the file-id
-        possible_paths = []
-        for p in (self.path, self.conflict_path):
-            if p == '<deleted>':
-                # special hard-coded path
-                continue
-            if p is not None:
-                possible_paths.append(p)
-        # Search the file-id in the parents with any path available
-        file_id = None
-        for revid in tree.get_parent_ids():
-            revtree = self._revision_tree(tree, revid)
-            for p in possible_paths:
-                file_id = revtree.path2id(p)
-                if file_id is not None:
-                    return revtree, file_id
-        return None, None
-
-    def action_take_this(self, tree):
-        if self.file_id is not None:
-            self._resolve_with_cleanups(tree, self.file_id, self.path,
-                                        winner='this')
-        else:
-            # Prior to bug #531967 we need to find back the file_id and restore
-            # the content from there
-            revtree, file_id = self._infer_file_id(tree)
-            tree.revert([revtree.id2path(file_id)],
-                        old_tree=revtree, backups=False)
-
-    def action_take_other(self, tree):
-        if self.file_id is not None:
-            self._resolve_with_cleanups(tree, self.file_id,
-                                        self.conflict_path,
-                                        winner='other')
-        else:
-            # Prior to bug #531967 we need to find back the file_id and restore
-            # the content from there
-            revtree, file_id = self._infer_file_id(tree)
-            tree.revert([revtree.id2path(file_id)],
-                        old_tree=revtree, backups=False)
-
-
-class ContentsConflict(PathConflict):
-    """The files are of different types (or both binary), or not present"""
-
-    has_files = True
-
-    typestring = 'contents conflict'
-
-    format = 'Contents conflict in %(path)s'
-
-    def associated_filenames(self):
-        return [self.path + suffix for suffix in ('.BASE', '.OTHER')]
-
-    def _resolve(self, tt, suffix_to_remove):
-        """Resolve the conflict.
-
-        :param tt: The TreeTransform where the conflict is resolved.
-        :param suffix_to_remove: Either 'THIS' or 'OTHER'
-
-        The resolution is symmetric: when taking THIS, OTHER is deleted and
-        item.THIS is renamed into item and vice-versa.
-        """
-        try:
-            # Delete 'item.THIS' or 'item.OTHER' depending on
-            # suffix_to_remove
-            tt.delete_contents(
-                tt.trans_id_tree_path(self.path + '.' + suffix_to_remove))
-        except errors.NoSuchFile:
-            # There are valid cases where 'item.suffix_to_remove' either
-            # never existed or was already deleted (including the case
-            # where the user deleted it)
-            pass
-        try:
-            this_path = tt._tree.id2path(self.file_id)
-        except errors.NoSuchId:
-            # The file is not present anymore. This may happen if the user
-            # deleted the file either manually or when resolving a conflict on
-            # the parent.  We may raise some exception to indicate that the
-            # conflict doesn't exist anymore and as such doesn't need to be
-            # resolved ? -- vila 20110615
-            this_tid = None
-        else:
-            this_tid = tt.trans_id_tree_path(this_path)
-        if this_tid is not None:
-            # Rename 'item.suffix_to_remove' (note that if
-            # 'item.suffix_to_remove' has been deleted, this is a no-op)
-            parent_tid = tt.get_tree_parent(this_tid)
-            tt.adjust_path(osutils.basename(self.path), parent_tid, this_tid)
-            tt.apply()
-
-    def action_take_this(self, tree):
-        self._resolve_with_cleanups(tree, 'OTHER')
-
-    def action_take_other(self, tree):
-        self._resolve_with_cleanups(tree, 'THIS')
-
-
-# TODO: There should be a base revid attribute to better inform the user about
-# how the conflicts were generated.
-class TextConflict(Conflict):
-    """The merge algorithm could not resolve all differences encountered."""
-
-    has_files = True
-
-    typestring = 'text conflict'
-
-    format = 'Text conflict in %(path)s'
-
-    rformat = '%(class)s(%(path)r, %(file_id)r)'
-
-    _conflict_re = re.compile(b'^(<{7}|={7}|>{7})')
-
-    def associated_filenames(self):
-        return [self.path + suffix for suffix in CONFLICT_SUFFIXES]
-
-    def _resolve(self, tt, winner_suffix):
-        """Resolve the conflict by copying one of .THIS or .OTHER into file.
-
-        :param tt: The TreeTransform where the conflict is resolved.
-        :param winner_suffix: Either 'THIS' or 'OTHER'
-
-        The resolution is symmetric, when taking THIS, item.THIS is renamed
-        into item and vice-versa. This takes one of the files as a whole
-        ignoring every difference that could have been merged cleanly.
-        """
-        # To avoid useless copies, we switch item and item.winner_suffix, only
-        # item will exist after the conflict has been resolved anyway.
-        item_tid = tt.trans_id_file_id(self.file_id)
-        item_parent_tid = tt.get_tree_parent(item_tid)
-        winner_path = self.path + '.' + winner_suffix
-        winner_tid = tt.trans_id_tree_path(winner_path)
-        winner_parent_tid = tt.get_tree_parent(winner_tid)
-        # Switch the paths to preserve the content
-        tt.adjust_path(osutils.basename(self.path),
-                       winner_parent_tid, winner_tid)
-        tt.adjust_path(osutils.basename(winner_path),
-                       item_parent_tid, item_tid)
-        # Associate the file_id to the right content
-        tt.unversion_file(item_tid)
-        tt.version_file(winner_tid, file_id=self.file_id)
-        tt.apply()
-
-    def action_auto(self, tree):
-        # GZ 2012-07-27: Using NotImplementedError to signal that a conflict
-        #                can't be auto resolved does not seem ideal.
-        try:
-            kind = tree.kind(self.path)
-        except errors.NoSuchFile:
-            return
-        if kind != 'file':
-            raise NotImplementedError("Conflict is not a file")
-        conflict_markers_in_line = self._conflict_re.search
-        # GZ 2012-07-27: What if not tree.has_id(self.file_id) due to removal?
-        with tree.get_file(self.path) as f:
-            for line in f:
-                if conflict_markers_in_line(line):
-                    raise NotImplementedError("Conflict markers present")
-
-    def action_take_this(self, tree):
-        self._resolve_with_cleanups(tree, 'THIS')
-
-    def action_take_other(self, tree):
-        self._resolve_with_cleanups(tree, 'OTHER')
-
-
-class HandledConflict(Conflict):
-    """A path problem that has been provisionally resolved.
-    This is intended to be a base class.
-    """
-
-    rformat = "%(class)s(%(action)r, %(path)r, %(file_id)r)"
-
-    def __init__(self, action, path, file_id=None):
-        Conflict.__init__(self, path, file_id)
-        self.action = action
-
-    def _cmp_list(self):
-        return Conflict._cmp_list(self) + [self.action]
-
-    def as_stanza(self):
-        s = Conflict.as_stanza(self)
-        s.add('action', self.action)
-        return s
-
-    def associated_filenames(self):
-        # Nothing has been generated here
-        return []
-
-
-class HandledPathConflict(HandledConflict):
-    """A provisionally-resolved path problem involving two paths.
-    This is intended to be a base class.
-    """
-
-    rformat = "%(class)s(%(action)r, %(path)r, %(conflict_path)r,"\
-        " %(file_id)r, %(conflict_file_id)r)"
-
-    def __init__(self, action, path, conflict_path, file_id=None,
-                 conflict_file_id=None):
-        HandledConflict.__init__(self, action, path, file_id)
-        self.conflict_path = conflict_path
-        # the factory blindly transfers the Stanza values to __init__,
-        # so they can be unicode.
-        if isinstance(conflict_file_id, str):
-            conflict_file_id = cache_utf8.encode(conflict_file_id)
-        self.conflict_file_id = conflict_file_id
-
-    def _cmp_list(self):
-        return HandledConflict._cmp_list(self) + [self.conflict_path,
-                                                  self.conflict_file_id]
-
-    def as_stanza(self):
-        s = HandledConflict.as_stanza(self)
-        s.add('conflict_path', self.conflict_path)
-        if self.conflict_file_id is not None:
-            s.add('conflict_file_id', self.conflict_file_id.decode('utf8'))
-
-        return s
-
-
-class DuplicateID(HandledPathConflict):
-    """Two files want the same file_id."""
-
-    typestring = 'duplicate id'
-
-    format = 'Conflict adding id to %(conflict_path)s.  %(action)s %(path)s.'
-
-
-class DuplicateEntry(HandledPathConflict):
-    """Two directory entries want to have the same name."""
-
-    typestring = 'duplicate'
-
-    format = 'Conflict adding file %(conflict_path)s.  %(action)s %(path)s.'
-
-    def action_take_this(self, tree):
-        tree.remove([self.conflict_path], force=True, keep_files=False)
-        tree.rename_one(self.path, self.conflict_path)
-
-    def action_take_other(self, tree):
-        tree.remove([self.path], force=True, keep_files=False)
-
-
-class ParentLoop(HandledPathConflict):
-    """An attempt to create an infinitely-looping directory structure.
-    This is rare, but can be produced like so:
-
-    tree A:
-      mv foo bar
-    tree B:
-      mv bar foo
-    merge A and B
-    """
-
-    typestring = 'parent loop'
-
-    format = 'Conflict moving %(path)s into %(conflict_path)s. %(action)s.'
-
-    def action_take_this(self, tree):
-        # just acccept brz proposal
-        pass
-
-    def action_take_other(self, tree):
-        with tree.transform() as tt:
-            p_tid = tt.trans_id_file_id(self.file_id)
-            parent_tid = tt.get_tree_parent(p_tid)
-            cp_tid = tt.trans_id_file_id(self.conflict_file_id)
-            cparent_tid = tt.get_tree_parent(cp_tid)
-            tt.adjust_path(osutils.basename(self.path), cparent_tid, cp_tid)
-            tt.adjust_path(osutils.basename(self.conflict_path),
-                           parent_tid, p_tid)
-            tt.apply()
-
-
-class UnversionedParent(HandledConflict):
-    """An attempt to version a file whose parent directory is not versioned.
-    Typically, the result of a merge where one tree unversioned the directory
-    and the other added a versioned file to it.
-    """
-
-    typestring = 'unversioned parent'
-
-    format = 'Conflict because %(path)s is not versioned, but has versioned'\
-             ' children.  %(action)s.'
-
-    # FIXME: We silently do nothing to make tests pass, but most probably the
-    # conflict shouldn't exist (the long story is that the conflict is
-    # generated with another one that can be resolved properly) -- vila 091224
-    def action_take_this(self, tree):
-        pass
-
-    def action_take_other(self, tree):
-        pass
-
-
-class MissingParent(HandledConflict):
-    """An attempt to add files to a directory that is not present.
-    Typically, the result of a merge where THIS deleted the directory and
-    the OTHER added a file to it.
-    See also: DeletingParent (same situation, THIS and OTHER reversed)
-    """
-
-    typestring = 'missing parent'
-
-    format = 'Conflict adding files to %(path)s.  %(action)s.'
-
-    def action_take_this(self, tree):
-        tree.remove([self.path], force=True, keep_files=False)
-
-    def action_take_other(self, tree):
-        # just acccept brz proposal
-        pass
-
-
-class DeletingParent(HandledConflict):
-    """An attempt to add files to a directory that is not present.
-    Typically, the result of a merge where one OTHER deleted the directory and
-    the THIS added a file to it.
-    """
-
-    typestring = 'deleting parent'
-
-    format = "Conflict: can't delete %(path)s because it is not empty.  "\
-             "%(action)s."
-
-    # FIXME: It's a bit strange that the default action is not coherent with
-    # MissingParent from the *user* pov.
-
-    def action_take_this(self, tree):
-        # just acccept brz proposal
-        pass
-
-    def action_take_other(self, tree):
-        tree.remove([self.path], force=True, keep_files=False)
-
-
-class NonDirectoryParent(HandledConflict):
-    """An attempt to add files to a directory that is not a directory or
-    an attempt to change the kind of a directory with files.
-    """
-
-    typestring = 'non-directory parent'
-
-    format = "Conflict: %(path)s is not a directory, but has files in it."\
-             "  %(action)s."
-
-    # FIXME: .OTHER should be used instead of .new when the conflict is created
-
-    def action_take_this(self, tree):
-        # FIXME: we should preserve that path when the conflict is generated !
-        if self.path.endswith('.new'):
-            conflict_path = self.path[:-(len('.new'))]
-            tree.remove([self.path], force=True, keep_files=False)
-            tree.add(conflict_path)
-        else:
-            raise NotImplementedError(self.action_take_this)
-
-    def action_take_other(self, tree):
-        # FIXME: we should preserve that path when the conflict is generated !
-        if self.path.endswith('.new'):
-            conflict_path = self.path[:-(len('.new'))]
-            tree.remove([conflict_path], force=True, keep_files=False)
-            tree.rename_one(self.path, conflict_path)
-        else:
-            raise NotImplementedError(self.action_take_other)
-
-
-ctype = {}
-
-
-def register_types(*conflict_types):
-    """Register a Conflict subclass for serialization purposes"""
-    global ctype
-    for conflict_type in conflict_types:
-        ctype[conflict_type.typestring] = conflict_type
-
-
-register_types(ContentsConflict, TextConflict, PathConflict, DuplicateID,
-               DuplicateEntry, ParentLoop, UnversionedParent, MissingParent,
-               DeletingParent, NonDirectoryParent)
+    def do(self, action, tree):
+        """Apply the specified action to the conflict.
+
+        :param action: The method name to call.
+
+        :param tree: The tree passed as a parameter to the method.
+        """
+        raise NotImplementedError(self.do)
+
+    def describe(self):
+        """Return a string description of this conflict."""
+        raise NotImplementedError(self.describe)

=== modified file 'breezy/delta.py'
--- breezy/delta.py	2020-02-18 01:57:45 +0000
+++ breezy/delta.py	2020-08-23 01:05:31 +0000
@@ -20,7 +20,7 @@
     osutils,
     trace,
     )
-from .tree import TreeChange
+from .bzr.inventorytree import InventoryTreeChange
 
 
 class TreeDelta(object):
@@ -327,14 +327,12 @@
         exe_change = False
         # files are "renamed" if they are moved or if name changes, as long
         # as it had a value
-        if None not in change.name and None not in change.parent_id and\
-                (change.name[0] != change.name[1] or change.parent_id[0] != change.parent_id[1]):
-            if change.copied:
-                copied = True
-                renamed = False
-            else:
-                renamed = True
-                copied = False
+        if change.copied:
+            copied = True
+            renamed = False
+        elif change.renamed:
+            renamed = True
+            copied = False
         else:
             copied = False
             renamed = False
@@ -397,7 +395,7 @@
         dec_new_path = decorate_path(item.path[1], item.kind[1], item.meta_modified())
         to_file.write(' => %s' % dec_new_path)
         if item.changed_content or item.meta_modified():
-            extra_modified.append(TreeChange(
+            extra_modified.append(InventoryTreeChange(
                 item.file_id, (item.path[1], item.path[1]),
                 item.changed_content,
                 item.versioned,

=== modified file 'breezy/errors.py'
--- breezy/errors.py	2020-07-28 02:11:05 +0000
+++ breezy/errors.py	2020-08-23 01:05:31 +0000
@@ -1282,15 +1282,15 @@
 
 class UnexpectedHttpStatus(InvalidHttpResponse):
 
-    _fmt = "Unexpected HTTP status %(code)d for %(path)s"
+    _fmt = "Unexpected HTTP status %(code)d for %(path)s: %(extra)s"
 
-    def __init__(self, path, code, msg=None):
+    def __init__(self, path, code, extra=None):
         self.path = path
         self.code = code
-        self.msg = msg
+        self.extra = extra or ''
         full_msg = 'status code %d unexpected' % code
-        if msg is not None:
-            full_msg += ': ' + msg
+        if extra is not None:
+            full_msg += ': ' + extra
         InvalidHttpResponse.__init__(
             self, path, full_msg)
 

=== modified file 'breezy/git/commit.py'
--- breezy/git/commit.py	2020-07-18 23:14:00 +0000
+++ breezy/git/commit.py	2020-08-23 01:05:31 +0000
@@ -19,6 +19,7 @@
 
 from dulwich.index import (
     commit_tree,
+    read_submodule_head,
     )
 import stat
 
@@ -42,7 +43,6 @@
     Blob,
     Commit,
     )
-from dulwich.index import read_submodule_head
 
 
 from .mapping import (
@@ -75,11 +75,24 @@
     def record_iter_changes(self, workingtree, basis_revid, iter_changes):
         seen_root = False
         for change in iter_changes:
+            if change.kind == (None, None):
+                # Ephemeral
+                continue
+            if change.versioned[0] and not change.copied:
+                file_id = self._mapping.generate_file_id(change.path[0])
+            elif change.versioned[1]:
+                file_id = self._mapping.generate_file_id(change.path[1])
+            else:
+                file_id = None
+            if change.path[1]:
+                parent_id_new = self._mapping.generate_file_id(osutils.dirname(change.path[1]))
+            else:
+                parent_id_new = None
             if change.kind[1] in ("directory",):
                 self._inv_delta.append(
-                    (change.path[0], change.path[1], change.file_id,
+                    (change.path[0], change.path[1], file_id,
                      entry_factory[change.kind[1]](
-                         change.file_id, change.name[1], change.parent_id[1])))
+                         file_id, change.name[1], parent_id_new)))
                 if change.kind[0] in ("file", "symlink"):
                     self._blobs[encode_git_path(change.path[0])] = None
                     self._any_changes = True
@@ -88,14 +101,14 @@
                 continue
             self._any_changes = True
             if change.path[1] is None:
-                self._inv_delta.append((change.path[0], change.path[1], change.file_id, None))
+                self._inv_delta.append((change.path[0], change.path[1], file_id, None))
                 self._deleted_paths.add(encode_git_path(change.path[0]))
                 continue
             try:
                 entry_kls = entry_factory[change.kind[1]]
             except KeyError:
                 raise KeyError("unknown kind %s" % change.kind[1])
-            entry = entry_kls(change.file_id, change.name[1], change.parent_id[1])
+            entry = entry_kls(file_id, change.name[1], parent_id_new)
             if change.kind[1] == "file":
                 entry.executable = change.executable[1]
                 blob = Blob()
@@ -104,10 +117,13 @@
                     blob.data = f.read()
                 finally:
                     f.close()
-                entry.text_size = len(blob.data)
-                entry.text_sha1 = osutils.sha_string(blob.data)
+                sha = blob.id
+                if st is not None:
+                    entry.text_size = st.st_size
+                else:
+                    entry.text_size = len(blob.data)
+                entry.git_sha1 = sha
                 self.store.add_object(blob)
-                sha = blob.id
             elif change.kind[1] == "symlink":
                 symlink_target = workingtree.get_symlink_target(change.path[1])
                 blob = Blob()
@@ -124,12 +140,12 @@
             else:
                 raise AssertionError("Unknown kind %r" % change.kind[1])
             mode = object_mode(change.kind[1], change.executable[1])
-            self._inv_delta.append((change.path[0], change.path[1], change.file_id, entry))
+            self._inv_delta.append((change.path[0], change.path[1], file_id, entry))
             if change.path[0] is not None:
                 self._deleted_paths.add(encode_git_path(change.path[0]))
             self._blobs[encode_git_path(change.path[1])] = (mode, sha)
             if st is not None:
-                yield change.path[1], (entry.text_sha1, st)
+                yield change.path[1], (entry.git_sha1, st)
         if not seen_root and len(self.parents) == 0:
             raise RootMissing()
         if getattr(workingtree, "basis_tree", False):

=== modified file 'breezy/git/mapping.py'
--- breezy/git/mapping.py	2020-07-18 23:14:00 +0000
+++ breezy/git/mapping.py	2020-08-23 01:05:31 +0000
@@ -160,7 +160,7 @@
     """Class that maps between Git and Bazaar semantics."""
     experimental = False
 
-    BZR_DUMMY_FILE = None
+    BZR_DUMMY_FILE = None  # type: Optional[str]
 
     def is_special_file(self, filename):
         return (filename in (self.BZR_DUMMY_FILE, ))

=== modified file 'breezy/git/remote.py'
--- breezy/git/remote.py	2020-07-18 23:14:00 +0000
+++ breezy/git/remote.py	2020-08-23 01:05:31 +0000
@@ -201,6 +201,8 @@
         return PermissionDenied(url, message)
     if message.endswith(' does not appear to be a git repository'):
         return NotBranchError(url, message)
+    if message == 'pre-receive hook declined':
+        return PermissionDenied(url, message)
     if re.match('(.+) is not a valid repository name',
                 message.splitlines()[0]):
         return NotBranchError(url, message)
@@ -600,11 +602,16 @@
         push_result.branch_push_result = None
         repo = self.find_repository()
         refname = self._get_selected_ref(name)
-        ref_chain, old_sha = self.get_refs_container().follow(refname)
-        if ref_chain:
-            actual_refname = ref_chain[-1]
-        else:
+        try:
+            ref_chain, old_sha = self.get_refs_container().follow(refname)
+        except NotBranchError:
             actual_refname = refname
+            old_sha = None
+        else:
+            if ref_chain:
+                actual_refname = ref_chain[-1]
+            else:
+                actual_refname = refname
         if isinstance(source, GitBranch) and lossy:
             raise errors.LossyPushToSameVCS(source.controldir, self)
         source_store = get_object_store(source.repository)
@@ -624,6 +631,7 @@
                     raise errors.NoRoundtrippingSupport(
                         source, self.open_branch(name=name, nascent_ok=True))
             if not overwrite:
+                old_sha = remote_refs.get(actual_refname)
                 if remote_divergence(old_sha, new_sha, source_store):
                     raise DivergedBranches(
                         source, self.open_branch(name, nascent_ok=True))

=== modified file 'breezy/git/tests/test_remote.py'
--- breezy/git/tests/test_remote.py	2020-07-18 23:14:00 +0000
+++ breezy/git/tests/test_remote.py	2020-08-23 01:05:31 +0000
@@ -135,6 +135,14 @@
         self.assertEqual(e.path, 'porridge/gaduhistory.git')
         self.assertEqual(e.extra, ': denied to jelmer')
 
+    def test_pre_receive_hook_declined(self):
+        e = parse_git_error(
+            "url",
+            'pre-receive hook declined')
+        self.assertIsInstance(e, PermissionDenied)
+        self.assertEqual(e.path, "url")
+        self.assertEqual(e.extra, ': pre-receive hook declined')
+
     def test_invalid_repo_name(self):
         e = parse_git_error(
             "url",

=== modified file 'breezy/git/tests/test_tree.py'
--- breezy/git/tests/test_tree.py	2020-06-21 22:00:40 +0000
+++ breezy/git/tests/test_tree.py	2020-08-23 01:05:31 +0000
@@ -25,7 +25,7 @@
 from dulwich.objects import Tree, Blob
 
 from breezy.delta import TreeDelta
-from breezy.tree import TreeChange
+from breezy.bzr.inventorytree import InventoryTreeChange as TreeChange
 from breezy.git.tree import (
     changes_from_git_changes,
     tree_delta_from_git_changes,

=== modified file 'breezy/git/tests/test_workingtree.py'
--- breezy/git/tests/test_workingtree.py	2020-06-19 21:26:53 +0000
+++ breezy/git/tests/test_workingtree.py	2020-08-23 01:05:31 +0000
@@ -21,8 +21,11 @@
 import stat
 
 from dulwich import __version__ as dulwich_version
-from dulwich.diff_tree import RenameDetector
+from dulwich.diff_tree import RenameDetector, tree_changes
 from dulwich.index import IndexEntry
+from dulwich.object_store import (
+    OverlayObjectStore,
+    )
 from dulwich.objects import (
     S_IFGITLINK,
     Blob,
@@ -35,12 +38,11 @@
     workingtree as _mod_workingtree,
     )
 from ...delta import TreeDelta
-from ...tree import TreeChange
+from ...bzr.inventorytree import InventoryTreeChange as TreeChange
 from ..mapping import (
     default_mapping,
     )
 from ..tree import (
-    changes_between_git_tree_and_working_copy,
     tree_delta_from_git_changes,
     )
 from ..workingtree import (
@@ -52,6 +54,22 @@
     )
 
 
+def changes_between_git_tree_and_working_copy(source_store, from_tree_sha, target,
+                                              want_unchanged=False,
+                                              want_unversioned=False,
+                                              rename_detector=None,
+                                              include_trees=True):
+    """Determine the changes between a git tree and a working tree with index.
+
+    """
+    to_tree_sha, extras = target.git_snapshot(want_unversioned=want_unversioned)
+    store = OverlayObjectStore([source_store, target.store])
+    return tree_changes(
+        store, from_tree_sha, to_tree_sha, include_trees=include_trees,
+        rename_detector=rename_detector,
+        want_unchanged=want_unchanged, change_type_same=True), extras
+
+
 class GitWorkingTreeTests(TestCaseWithTransport):
 
     def setUp(self):

=== modified file 'breezy/git/transform.py'
--- breezy/git/transform.py	2020-07-20 02:02:23 +0000
+++ breezy/git/transform.py	2020-08-23 01:05:31 +0000
@@ -19,13 +19,29 @@
 
 import errno
 import os
-from stat import S_ISREG
+import posixpath
+from stat import S_IEXEC, S_ISREG
 import time
 
-from .. import errors, multiparent, osutils, trace, ui, urlutils
+from .mapping import encode_git_path, mode_kind, mode_is_executable, object_mode
+from .tree import GitTree, GitTreeDirectory, GitTreeSymlink, GitTreeFile
+
+from .. import (
+    annotate,
+    conflicts,
+    errors,
+    multiparent,
+    osutils,
+    revision as _mod_revision,
+    trace,
+    ui,
+    urlutils,
+    )
 from ..i18n import gettext
 from ..mutabletree import MutableTree
+from ..tree import InterTree, TreeChange
 from ..transform import (
+    PreviewTree,
     TreeTransform,
     _TransformResults,
     _FileMover,
@@ -39,8 +55,8 @@
     MalformedTransform,
     )
 
-from ..bzr import inventory
-from ..bzr.transform import TransformPreview as GitTransformPreview
+from dulwich.index import commit_tree, blob_from_path_and_stat
+from dulwich.objects import Blob
 
 
 class TreeTransformBase(TreeTransform):
@@ -58,19 +74,17 @@
         super(TreeTransformBase, self).__init__(tree, pb=pb)
         # mapping of trans_id => (sha1 of content, stat_value)
         self._observed_sha1s = {}
-        # Mapping of trans_id -> new file_id
-        self._new_id = {}
-        # Mapping of old file-id -> trans_id
-        self._non_present_ids = {}
-        # Mapping of new file_id -> trans_id
-        self._r_new_id = {}
+        # Set of versioned trans ids
+        self._versioned = set()
         # The trans_id that will be used as the tree root
-        if tree.is_versioned(''):
-            self._new_root = self.trans_id_tree_path('')
-        else:
-            self._new_root = None
+        self.root = self.trans_id_tree_path('')
         # Whether the target is case sensitive
         self._case_sensitive_target = case_sensitive
+        self._symlink_target = {}
+
+    @property
+    def mapping(self):
+        return self._tree.mapping
 
     def finalize(self):
         """Release the working tree lock, if held.
@@ -85,49 +99,16 @@
         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()
+        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
@@ -147,26 +128,12 @@
             return
         if len(new_roots) != 1:
             raise ValueError('A tree cannot have two roots!')
-        if self._new_root is None:
-            self._new_root = new_roots[0]
-            return
         old_new_root = new_roots[0]
         # unversion the new root's directory.
-        if self.final_kind(self._new_root) is None:
-            file_id = self.final_file_id(old_new_root)
-        else:
-            file_id = self.final_file_id(self._new_root)
-        if old_new_root in self._new_id:
+        if old_new_root in self._versioned:
             self.cancel_versioning(old_new_root)
         else:
             self.unversion_file(old_new_root)
-        # if, at this stage, root still has an old file_id, zap it so we can
-        # stick a new one in.
-        if (self.tree_file_id(self._new_root) is not None
-                and self._new_root not in self._removed_id):
-            self.unversion_file(self._new_root)
-        if file_id is not None:
-            self.version_file(self._new_root, file_id=file_id)
 
         # Now move children of new root into old root directory.
         # Ensure all children are registered with the transaction, but don't
@@ -174,7 +141,7 @@
         list(self.iter_tree_children(old_new_root))
         # Move all children of new root into old root directory.
         for child in self.by_parent().get(old_new_root, []):
-            self.adjust_path(self.final_name(child), self._new_root, child)
+            self.adjust_path(self.final_name(child), self.root, child)
 
         # Ensure old_new_root has no directory.
         if old_new_root in self._new_contents:
@@ -183,8 +150,8 @@
             self.delete_contents(old_new_root)
 
         # prevent deletion of root directory.
-        if self._new_root in self._removed_contents:
-            self.cancel_deletion(self._new_root)
+        if self.root in self._removed_contents:
+            self.cancel_deletion(self.root)
 
         # destroy path info for old_new_root.
         del self._new_parent[old_new_root]
@@ -198,24 +165,14 @@
         """
         if file_id is None:
             raise ValueError('None is not a valid file id')
-        if file_id in self._r_new_id and self._r_new_id[file_id] is not None:
-            return self._r_new_id[file_id]
-        else:
-            try:
-                path = self._tree.id2path(file_id)
-            except errors.NoSuchId:
-                if file_id in self._non_present_ids:
-                    return self._non_present_ids[file_id]
-                else:
-                    trans_id = self._assign_id()
-                    self._non_present_ids[file_id] = trans_id
-                    return trans_id
-            else:
-                return self.trans_id_tree_path(path)
+        path = self.mapping.parse_file_id(file_id)
+        return self.trans_id_tree_path(path)
 
     def version_file(self, trans_id, file_id=None):
         """Schedule a file to become versioned."""
-        raise NotImplementedError(self.version_file)
+        if trans_id in self._versioned:
+            raise errors.DuplicateKey(key=trans_id)
+        self._versioned.add(trans_id)
 
     def cancel_versioning(self, trans_id):
         """Undo a previous versioning of a file"""
@@ -232,55 +189,27 @@
             stale_ids = self._needs_rename.difference(self._new_name)
             stale_ids.difference_update(self._new_parent)
             stale_ids.difference_update(self._new_contents)
-            stale_ids.difference_update(self._new_id)
+            stale_ids.difference_update(self._versioned)
             needs_rename = self._needs_rename.difference(stale_ids)
             id_sets = (needs_rename, self._new_executability)
         else:
             id_sets = (self._new_name, self._new_parent, self._new_contents,
-                       self._new_id, self._new_executability)
+                       self._versioned, self._new_executability)
         for id_set in id_sets:
             new_ids.update(id_set)
         return sorted(FinalPaths(self).get_paths(new_ids))
 
-    def tree_file_id(self, trans_id):
-        """Determine the file id associated with the trans_id in the tree"""
-        path = self.tree_path(trans_id)
-        if path is None:
-            return None
-        # the file is old; the old id is still valid
-        if self._new_root == trans_id:
-            return self._tree.path2id('')
-        return self._tree.path2id(path)
-
     def final_is_versioned(self, trans_id):
-        return self.final_file_id(trans_id) is not None
-
-    def final_file_id(self, trans_id):
-        """Determine the file id after any changes are applied, or None.
-
-        None indicates that the file will not be versioned after changes are
-        applied.
-        """
-        try:
-            return self._new_id[trans_id]
-        except KeyError:
-            if trans_id in self._removed_id:
-                return None
-        return self.tree_file_id(trans_id)
-
-    def inactive_file_id(self, trans_id):
-        """Return the inactive file_id associated with a transaction id.
-        That is, the one in the tree or in non_present_ids.
-        The file_id may actually be active, too.
-        """
-        file_id = self.tree_file_id(trans_id)
-        if file_id is not None:
-            return file_id
-        for key, value in self._non_present_ids.items():
-            if value == trans_id:
-                return key
-
-    def find_conflicts(self):
+        if trans_id in self._versioned:
+            return True
+        if trans_id in self._removed_id:
+            return False
+        orig_path = self.tree_path(trans_id)
+        if orig_path is None:
+            return False
+        return self._tree.is_versioned(orig_path)
+
+    def find_raw_conflicts(self):
         """Find any violations of inventory or filesystem invariants"""
         if self._done is True:
             raise ReusingTransform()
@@ -289,7 +218,6 @@
         # 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))
@@ -299,7 +227,7 @@
         return conflicts
 
     def _check_malformed(self):
-        conflicts = self.find_conflicts()
+        conflicts = self.find_raw_conflicts()
         if len(conflicts) != 0:
             raise MalformedTransform(conflicts=conflicts)
 
@@ -315,8 +243,11 @@
         for trans_id in self._removed_id:
             path = self.tree_path(trans_id)
             if path is not None:
-                if self._tree.stored_kind(path) == 'directory':
-                    parents.append(trans_id)
+                try:
+                    if self._tree.stored_kind(path) == 'directory':
+                        parents.append(trans_id)
+                except errors.NoSuchFile:
+                    pass
             elif self.tree_kind(trans_id) == 'directory':
                 parents.append(trans_id)
 
@@ -385,27 +316,13 @@
                     break
         return conflicts
 
-    def _unversioned_parents(self, by_parent):
-        """If parent directories are versioned, children must be versioned."""
-        conflicts = []
-        for parent_id, children in by_parent.items():
-            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:
+        for trans_id in self._versioned:
             kind = self.final_kind(trans_id)
             if kind == 'symlink' and not self._tree.supports_symlinks():
                 # Ignore symlinks as they are not supported on this platform
@@ -611,7 +528,7 @@
     def _affected_ids(self):
         """Return the set of transform ids affected by the transform"""
         trans_ids = set(self._removed_id)
-        trans_ids.update(self._new_id)
+        trans_ids.update(self._versioned)
         trans_ids.update(self._removed_contents)
         trans_ids.update(self._new_contents)
         trans_ids.update(self._new_executability)
@@ -619,130 +536,78 @@
         trans_ids.update(self._new_parent)
         return trans_ids
 
-    def _get_file_id_maps(self):
-        """Return mapping of file_ids to trans_ids in the to and from states"""
-        trans_ids = self._affected_ids()
-        from_trans_ids = {}
-        to_trans_ids = {}
-        # Build up two dicts: trans_ids associated with file ids in the
-        # FROM state, vs the TO state.
-        for trans_id in trans_ids:
-            from_file_id = self.tree_file_id(trans_id)
-            if from_file_id is not None:
-                from_trans_ids[from_file_id] = trans_id
-            to_file_id = self.final_file_id(trans_id)
-            if to_file_id is not None:
-                to_trans_ids[to_file_id] = trans_id
-        return from_trans_ids, to_trans_ids
-
-    def _from_file_data(self, from_trans_id, from_versioned, from_path):
-        """Get data about a file in the from (tree) state
-
-        Return a (name, parent, kind, executable) tuple
-        """
-        from_path = self._tree_id_paths.get(from_trans_id)
-        if from_versioned:
-            # get data from working tree if versioned
-            from_entry = next(self._tree.iter_entries_by_dir(
-                specific_files=[from_path]))[1]
-            from_name = from_entry.name
-            from_parent = from_entry.parent_id
-        else:
-            from_entry = None
-            if from_path is None:
-                # File does not exist in FROM state
-                from_name = None
-                from_parent = None
-            else:
-                # File exists, but is not versioned.  Have to use path-
-                # splitting stuff
-                from_name = os.path.basename(from_path)
-                tree_parent = self.get_tree_parent(from_trans_id)
-                from_parent = self.tree_file_id(tree_parent)
-        if from_path is not None:
-            from_kind, from_executable, from_stats = \
-                self._tree._comparison_data(from_entry, from_path)
-        else:
-            from_kind = None
-            from_executable = False
-        return from_name, from_parent, from_kind, from_executable
-
-    def _to_file_data(self, to_trans_id, from_trans_id, from_executable):
-        """Get data about a file in the to (target) state
-
-        Return a (name, parent, kind, executable) tuple
-        """
-        to_name = self.final_name(to_trans_id)
-        to_kind = self.final_kind(to_trans_id)
-        to_parent = self.final_file_id(self.final_parent(to_trans_id))
-        if to_trans_id in self._new_executability:
-            to_executable = self._new_executability[to_trans_id]
-        elif to_trans_id == from_trans_id:
-            to_executable = from_executable
-        else:
-            to_executable = False
-        return to_name, to_parent, to_kind, to_executable
-
-    def iter_changes(self):
+    def iter_changes(self, want_unversioned=False):
         """Produce output in the same format as Tree.iter_changes.
 
         Will produce nonsensical results if invoked while inventory/filesystem
-        conflicts (as reported by TreeTransform.find_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.
+        conflicts (as reported by TreeTransform.find_raw_conflicts()) are present.
         """
         final_paths = FinalPaths(self)
-        from_trans_ids, to_trans_ids = self._get_file_id_maps()
+        trans_ids = self._affected_ids()
         results = []
-        # Now iterate through all active file_ids
-        for file_id in set(from_trans_ids).union(to_trans_ids):
+        # Now iterate through all active paths
+        for trans_id in trans_ids:
+            from_path = self.tree_path(trans_id)
             modified = False
-            from_trans_id = from_trans_ids.get(file_id)
             # find file ids, and determine versioning state
-            if from_trans_id is None:
+            if from_path is None:
                 from_versioned = False
-                from_trans_id = to_trans_ids[file_id]
             else:
-                from_versioned = True
-            to_trans_id = to_trans_ids.get(file_id)
-            if to_trans_id is None:
+                from_versioned = self._tree.is_versioned(from_path)
+            if not want_unversioned and not from_versioned:
+                from_path = None
+            to_path = final_paths.get_path(trans_id)
+            if to_path is None:
                 to_versioned = False
-                to_trans_id = from_trans_id
-            else:
-                to_versioned = True
-
-            if not from_versioned:
-                from_path = None
-            else:
-                from_path = self._tree_id_paths.get(from_trans_id)
-            if not to_versioned:
+            else:
+                to_versioned = self.final_is_versioned(trans_id)
+            if not want_unversioned and not to_versioned:
                 to_path = None
-            else:
-                to_path = final_paths.get_path(to_trans_id)
-
-            from_name, from_parent, from_kind, from_executable = \
-                self._from_file_data(from_trans_id, from_versioned, from_path)
-
-            to_name, to_parent, to_kind, to_executable = \
-                self._to_file_data(to_trans_id, from_trans_id, from_executable)
-
-            if from_kind != to_kind:
+
+            if from_versioned:
+                # get data from working tree if versioned
+                from_entry = next(self._tree.iter_entries_by_dir(
+                    specific_files=[from_path]))[1]
+                from_name = from_entry.name
+            else:
+                from_entry = None
+                if from_path is None:
+                    # File does not exist in FROM state
+                    from_name = None
+                else:
+                    # File exists, but is not versioned.  Have to use path-
+                    # splitting stuff
+                    from_name = os.path.basename(from_path)
+            if from_path is not None:
+                from_kind, from_executable, from_stats = \
+                    self._tree._comparison_data(from_entry, from_path)
+            else:
+                from_kind = None
+                from_executable = False
+
+            to_name = self.final_name(trans_id)
+            to_kind = self.final_kind(trans_id)
+            if trans_id in self._new_executability:
+                to_executable = self._new_executability[trans_id]
+            else:
+                to_executable = from_executable
+
+            if from_versioned and from_kind != to_kind:
                 modified = True
             elif to_kind in ('file', 'symlink') and (
-                    to_trans_id != from_trans_id
-                    or to_trans_id in self._new_contents):
+                    trans_id in self._new_contents):
                 modified = True
             if (not modified and from_versioned == to_versioned
-                and from_parent == to_parent and from_name == to_name
+                and from_path == to_path
+                and from_name == to_name
                     and from_executable == to_executable):
                 continue
+            if (from_path, to_path) == (None, None):
+                continue
             results.append(
                 TreeChange(
-                    file_id, (from_path, to_path), modified,
+                    (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)))
@@ -757,7 +622,7 @@
         The tree is a snapshot, and altering the TreeTransform will invalidate
         it.
         """
-        raise NotImplementedError(self.get_preview_tree)
+        return GitPreviewTree(self)
 
     def commit(self, branch, message, merge_parents=None, strict=False,
                timestamp=None, timezone=None, committer=None, authors=None,
@@ -784,7 +649,7 @@
         """
         self._check_malformed()
         if strict:
-            unversioned = set(self._new_contents).difference(set(self._new_id))
+            unversioned = set(self._new_contents).difference(set(self._versioned))
             for trans_id in unversioned:
                 if not self.final_is_versioned(trans_id):
                     raise errors.StrictCommitFailed()
@@ -841,104 +706,6 @@
             return ()
         return (self._tree.get_file_lines(path),)
 
-    def serialize(self, serializer):
-        """Serialize this TreeTransform.
-
-        :param serializer: A Serialiser like pack.ContainerSerializer.
-        """
-        from .. import bencode
-        new_name = {k.encode('utf-8'): v.encode('utf-8')
-                    for k, v in self._new_name.items()}
-        new_parent = {k.encode('utf-8'): v.encode('utf-8')
-                      for k, v in self._new_parent.items()}
-        new_id = {k.encode('utf-8'): v
-                  for k, v in self._new_id.items()}
-        new_executability = {k.encode('utf-8'): int(v)
-                             for k, v in self._new_executability.items()}
-        tree_path_ids = {k.encode('utf-8'): v.encode('utf-8')
-                         for k, v in self._tree_path_ids.items()}
-        non_present_ids = {k: v.encode('utf-8')
-                           for k, v in self._non_present_ids.items()}
-        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(self._new_contents.items()):
-            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 attribs[b'_new_name'].items()}
-        self._new_parent = {k.decode('utf-8'): v.decode('utf-8')
-                            for k, v in attribs[b'_new_parent'].items()}
-        self._new_executability = {
-            k.decode('utf-8'): bool(v)
-            for k, v in attribs[b'_new_executability'].items()}
-        self._new_id = {k.decode('utf-8'): v
-                        for k, v in attribs[b'_new_id'].items()}
-        self._r_new_id = {v: k for k, v in self._new_id.items()}
-        self._tree_path_ids = {}
-        self._tree_id_paths = {}
-        for bytepath, trans_id in attribs[b'_tree_path_ids'].items():
-            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 attribs[b'_non_present_ids'].items()}
-        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.
 
@@ -994,6 +761,35 @@
         """
         raise NotImplementedError(self.apply)
 
+    def cook_conflicts(self, raw_conflicts):
+        """Generate a list of cooked conflicts, sorted by file path"""
+        if not raw_conflicts:
+            return
+        fp = FinalPaths(self)
+        from .workingtree import TextConflict
+        for c in raw_conflicts:
+            if c[0] == 'text conflict':
+                yield TextConflict(fp.get_path(c[1]))
+            elif c[0] == 'duplicate':
+                yield TextConflict(fp.get_path(c[2]))
+            elif c[0] == 'contents conflict':
+                yield TextConflict(fp.get_path(c[1][0]))
+            elif c[0] == 'missing parent':
+                # TODO(jelmer): This should not make it to here
+                yield TextConflict(fp.get_path(c[2]))
+            elif c[0] == 'non-directory parent':
+                yield TextConflict(fp.get_path(c[2]))
+            elif c[0] == 'deleting parent':
+                # TODO(jelmer): This should not make it to here
+                yield TextConflict(fp.get_path(c[2]))
+            elif c[0] == 'parent loop':
+                # TODO(jelmer): This should not make it to here
+                yield TextConflict(fp.get_path(c[2]))
+            elif c[0] == 'path conflict':
+                yield TextConflict(fp.get_path(c[1]))
+            else:
+                raise AssertionError('unknown conflict %s' % c[0])
+
 
 class DiskTreeTransform(TreeTransformBase):
     """Tree transform storing its contents on disk."""
@@ -1204,6 +1000,7 @@
                 path = None
             trace.warning(
                 'Unable to create symlink "%s" on this filesystem.' % (path,))
+            self._symlink_target[trans_id] = target
         # We add symlink to _new_contents even if they are unsupported
         # and not created. These entries are subsequently used to avoid
         # conflicts on platforms that don't support symlink
@@ -1228,6 +1025,88 @@
         handle_orphan = conf.get('transform.orphan_policy')
         handle_orphan(self, trans_id, parent_id)
 
+    def final_entry(self, trans_id):
+        is_versioned = self.final_is_versioned(trans_id)
+        fp = FinalPaths(self)
+        tree_path = fp.get_path(trans_id)
+        if trans_id in self._new_contents:
+            path = self._limbo_name(trans_id)
+            st = os.lstat(path)
+            kind = mode_kind(st.st_mode)
+            name = self.final_name(trans_id)
+            file_id = self._tree.mapping.generate_file_id(tree_path)
+            parent_id = self._tree.mapping.generate_file_id(os.path.dirname(tree_path))
+            if kind == 'directory':
+                return GitTreeDirectory(
+                    file_id, self.final_name(trans_id), parent_id=parent_id), is_versioned
+            executable = mode_is_executable(st.st_mode)
+            mode = object_mode(kind, executable)
+            blob = blob_from_path_and_stat(encode_git_path(path), st)
+            if kind == 'symlink':
+                return GitTreeSymlink(
+                    file_id, name, parent_id,
+                    decode_git_path(blob.data)), is_versioned
+            elif kind == 'file':
+                return GitTreeFile(
+                    file_id, name, executable=executable, parent_id=parent_id,
+                    git_sha1=blob.id, text_size=len(blob.data)), is_versioned
+            else:
+                raise AssertionError(kind)
+        elif trans_id in self._removed_contents:
+            return None, None
+        else:
+            orig_path = self.tree_path(trans_id)
+            if orig_path is None:
+                return None, None
+            file_id = self._tree.mapping.generate_file_id(tree_path)
+            if tree_path == '':
+                parent_id = None
+            else:
+                parent_id = self._tree.mapping.generate_file_id(os.path.dirname(tree_path))
+            try:
+                ie = next(self._tree.iter_entries_by_dir(
+                    specific_files=[orig_path]))[1]
+                ie.file_id = file_id
+                ie.parent_id = parent_id
+                return ie, is_versioned
+            except StopIteration:
+                try:
+                    if self.tree_kind(trans_id) == 'directory':
+                        return GitTreeDirectory(
+                            file_id, self.final_name(trans_id), parent_id=parent_id), is_versioned
+                except OSError as e:
+                    if e.errno != errno.ENOTDIR:
+                        raise
+                return None, None
+
+    def final_git_entry(self, trans_id):
+        if trans_id in self._new_contents:
+            path = self._limbo_name(trans_id)
+            st = os.lstat(path)
+            kind = mode_kind(st.st_mode)
+            if kind == 'directory':
+                return None, None
+            executable = mode_is_executable(st.st_mode)
+            mode = object_mode(kind, executable)
+            blob = blob_from_path_and_stat(encode_git_path(path), st)
+        elif trans_id in self._removed_contents:
+            return None, None
+        else:
+            orig_path = self.tree_path(trans_id)
+            kind = self._tree.kind(orig_path)
+            executable = self._tree.is_executable(orig_path)
+            mode = object_mode(kind, executable)
+            if kind == 'symlink':
+                contents = self._tree.get_symlink_target(orig_path)
+            elif kind == 'file':
+                contents = self._tree.get_file_text(orig_path)
+            elif kind == 'directory':
+                return None, None
+            else:
+                raise AssertionError(kind)
+            blob = Blob.from_string(contents)
+        return blob, mode
+
 
 class GitTreeTransform(DiskTreeTransform):
     """Represent a tree transformation.
@@ -1448,20 +1327,11 @@
         self._limbo_children_names[parent][filename] = trans_id
         return limbo_name
 
-    def version_file(self, trans_id, file_id=None):
-        """Schedule a file to become versioned."""
-        if file_id is None:
-            raise ValueError()
-        unique_add(self._new_id, trans_id, file_id)
-        unique_add(self._r_new_id, file_id, trans_id)
-
     def cancel_versioning(self, trans_id):
         """Undo a previous versioning of a file"""
-        file_id = self._new_id[trans_id]
-        del self._new_id[trans_id]
-        del self._r_new_id[file_id]
+        self._versioned.remove(trans_id)
 
-    def apply(self, no_conflicts=False, precomputed_delta=None, _mover=None):
+    def apply(self, no_conflicts=False, _mover=None):
         """Apply all changes to the inventory and filesystem.
 
         If filesystem or inventory conflicts are present, MalformedTransform
@@ -1471,8 +1341,6 @@
 
         :param no_conflicts: if True, the caller guarantees there are no
             conflicts, so no check is made.
-        :param precomputed_delta: An inventory delta to use instead of
-            calculating one.
         :param _mover: Supply an alternate FileMover, for testing
         """
         for hook in MutableTree.hooks['pre_transform']:
@@ -1481,14 +1349,9 @@
             self._check_malformed()
         self.rename_count = 0
         with ui.ui_factory.nested_progress_bar() as child_pb:
-            if precomputed_delta is None:
-                child_pb.update(gettext('Apply phase'), 0, 2)
-                changes = self._generate_transform_changes()
-                offset = 1
-            else:
-                changes = [
-                    (op, np, ie) for (op, np, fid, ie) in precomputed_delta]
-                offset = 0
+            child_pb.update(gettext('Apply phase'), 0, 2)
+            index_changes = self._generate_index_changes()
+            offset = 1
             if _mover is None:
                 mover = _FileMover()
             else:
@@ -1503,9 +1366,7 @@
                 raise
             else:
                 mover.apply_deletions()
-        if self.final_file_id(self.root) is None:
-            changes = [e for e in changes if e[0] != '']
-        self._tree._apply_transform_delta(changes)
+        self._tree._apply_index_changes(index_changes)
         self._done = True
         self.finalize()
         return _TransformResults(modified_paths, self.rename_count)
@@ -1588,97 +1449,354 @@
         self._new_contents.clear()
         return modified_paths
 
-    def _inventory_altered(self):
-        """Determine which trans_ids need new Inventory entries.
-
-        An new entry is needed when anything that would be reflected by an
-        inventory entry changes, including file name, file_id, parent file_id,
-        file kind, and the execute bit.
-
-        Some care is taken to return entries with real changes, not cases
-        where the value is deleted and then restored to its original value,
-        but some actually unchanged values may be returned.
-
-        :returns: A list of (path, trans_id) for all items requiring an
-            inventory change. Ordered by path.
-        """
+    def _generate_index_changes(self):
+        """Generate an inventory delta for the current transform."""
+        removed_id = set(self._removed_id)
+        removed_id.update(self._removed_contents)
+        changes = {}
         changed_ids = set()
-        # Find entries whose file_ids are new (or changed).
-        new_file_id = set(t for t in self._new_id
-                          if self._new_id[t] != self.tree_file_id(t))
-        for id_set in [self._new_name, self._new_parent, new_file_id,
+        for id_set in [self._new_name, self._new_parent,
                        self._new_executability]:
             changed_ids.update(id_set)
-        # removing implies a kind change
-        changed_kind = set(self._removed_contents)
+        for id_set in [self._new_name, self._new_parent]:
+            removed_id.update(id_set)
         # so does adding
-        changed_kind.intersection_update(self._new_contents)
+        changed_kind = set(self._new_contents)
         # Ignore entries that are already known to have changed.
         changed_kind.difference_update(changed_ids)
         #  to keep only the truly changed ones
         changed_kind = (t for t in changed_kind
                         if self.tree_kind(t) != self.final_kind(t))
-        # all kind changes will alter the inventory
         changed_ids.update(changed_kind)
-        # To find entries with changed parent_ids, find parents which existed,
-        # but changed file_id.
-        # Now add all their children to the set.
-        for parent_trans_id in new_file_id:
-            changed_ids.update(self.iter_tree_children(parent_trans_id))
-        return sorted(FinalPaths(self).get_paths(changed_ids))
-
-    def _generate_transform_changes(self):
-        """Generate an inventory delta for the current transform."""
-        changes = []
-        new_paths = self._inventory_altered()
-        total_entries = len(new_paths) + len(self._removed_id)
+        for t in changed_kind:
+            if self.final_kind(t) == 'directory':
+                removed_id.add(t)
+                changed_ids.remove(t)
+        new_paths = sorted(FinalPaths(self).get_paths(changed_ids))
+        total_entries = len(new_paths) + len(removed_id)
         with ui.ui_factory.nested_progress_bar() as child_pb:
-            for num, trans_id in enumerate(self._removed_id):
+            for num, trans_id in enumerate(removed_id):
                 if (num % 10) == 0:
                     child_pb.update(gettext('removing file'),
                                     num, total_entries)
-                if trans_id == self._new_root:
-                    file_id = self._tree.path2id('')
-                else:
-                    file_id = self.tree_file_id(trans_id)
-                # File-id isn't really being deleted, just moved
-                if file_id in self._r_new_id:
+                try:
+                    path = self._tree_id_paths[trans_id]
+                except KeyError:
                     continue
-                path = self._tree_id_paths[trans_id]
-                changes.append((path, None, None))
-            new_path_file_ids = dict((t, self.final_file_id(t)) for p, t in
-                                     new_paths)
+                changes[path] = (None, None, None, None)
             for num, (path, trans_id) in enumerate(new_paths):
                 if (num % 10) == 0:
                     child_pb.update(gettext('adding file'),
-                                    num + len(self._removed_id), total_entries)
-                file_id = new_path_file_ids[trans_id]
-                if file_id is None:
-                    continue
+                                    num + len(removed_id), total_entries)
+
                 kind = self.final_kind(trans_id)
                 if kind is None:
-                    kind = self._tree.stored_kind(self._tree.id2path(file_id))
-                parent_trans_id = self.final_parent(trans_id)
-                parent_file_id = new_path_file_ids.get(parent_trans_id)
-                if parent_file_id is None:
-                    parent_file_id = self.final_file_id(parent_trans_id)
-                if trans_id in self._new_reference_revision:
-                    new_entry = inventory.TreeReference(
-                        file_id,
-                        self._new_name[trans_id],
-                        self.final_file_id(self._new_parent[trans_id]),
-                        None, self._new_reference_revision[trans_id])
-                else:
-                    new_entry = inventory.make_entry(kind,
-                                                     self.final_name(trans_id),
-                                                     parent_file_id, file_id)
-                try:
-                    old_path = self._tree.id2path(new_entry.file_id)
-                except errors.NoSuchId:
-                    old_path = None
-                new_executability = self._new_executability.get(trans_id)
-                if new_executability is not None:
-                    new_entry.executable = new_executability
-                changes.append(
-                    (old_path, path, new_entry))
-        return changes
+                    continue
+                versioned = self.final_is_versioned(trans_id)
+                if not versioned:
+                    continue
+                executability = self._new_executability.get(trans_id)
+                reference_revision = self._new_reference_revision.get(trans_id)
+                symlink_target = self._symlink_target.get(trans_id)
+                changes[path] = (
+                    kind, executability, reference_revision, symlink_target)
+        return [(p, k, e, rr, st) for (p, (k, e, rr, st)) in changes.items()]
+
+
+class GitTransformPreview(GitTreeTransform):
+    """A TreeTransform for generating preview trees.
+
+    Unlike TreeTransform, this version works when the input tree is a
+    RevisionTree, rather than a WorkingTree.  As a result, it tends to ignore
+    unversioned files in the input tree.
+    """
+
+    def __init__(self, tree, pb=None, case_sensitive=True):
+        tree.lock_read()
+        limbodir = osutils.mkdtemp(prefix='bzr-limbo-')
+        DiskTreeTransform.__init__(self, tree, limbodir, pb, case_sensitive)
+
+    def canonical_path(self, path):
+        return path
+
+    def tree_kind(self, trans_id):
+        path = self.tree_path(trans_id)
+        if path is None:
+            return None
+        kind = self._tree.path_content_summary(path)[0]
+        if kind == 'missing':
+            kind = None
+        return kind
+
+    def _set_mode(self, trans_id, mode_id, typefunc):
+        """Set the mode of new file contents.
+        The mode_id is the existing file to get the mode from (often the same
+        as trans_id).  The operation is only performed if there's a mode match
+        according to typefunc.
+        """
+        # is it ok to ignore this?  probably
+        pass
+
+    def iter_tree_children(self, parent_id):
+        """Iterate through the entry's tree children, if any"""
+        try:
+            path = self._tree_id_paths[parent_id]
+        except KeyError:
+            return
+        try:
+            for child in self._tree.iter_child_entries(path):
+                childpath = joinpath(path, child.name)
+                yield self.trans_id_tree_path(childpath)
+        except errors.NoSuchFile:
+            return
+
+    def new_orphan(self, trans_id, parent_id):
+        raise NotImplementedError(self.new_orphan)
+
+
+class GitPreviewTree(PreviewTree, GitTree):
+    """Partial implementation of Tree to support show_diff_trees"""
+
+    def __init__(self, transform):
+        PreviewTree.__init__(self, transform)
+        self.store = transform._tree.store
+        self.mapping = transform._tree.mapping
+        self._final_paths = FinalPaths(transform)
+
+    def supports_setting_file_ids(self):
+        return False
+
+    def _supports_executable(self):
+        return self._transform._limbo_supports_executable()
+
+    def walkdirs(self, prefix=''):
+        pending = [self._transform.root]
+        while len(pending) > 0:
+            parent_id = pending.pop()
+            children = []
+            subdirs = []
+            prefix = prefix.rstrip('/')
+            parent_path = self._final_paths.get_path(parent_id)
+            for child_id in self._all_children(parent_id):
+                path_from_root = self._final_paths.get_path(child_id)
+                basename = self._transform.final_name(child_id)
+                kind = self._transform.final_kind(child_id)
+                if kind is not None:
+                    versioned_kind = kind
+                else:
+                    kind = 'unknown'
+                    versioned_kind = self._transform._tree.stored_kind(
+                        path_from_root)
+                if versioned_kind == 'directory':
+                    subdirs.append(child_id)
+                children.append((path_from_root, basename, kind, None,
+                                 versioned_kind))
+            children.sort()
+            if parent_path.startswith(prefix):
+                yield parent_path, children
+            pending.extend(sorted(subdirs, key=self._final_paths.get_path,
+                                  reverse=True))
+
+    def iter_changes(self, from_tree, include_unchanged=False,
+                     specific_files=None, pb=None, extra_trees=None,
+                     require_versioned=True, want_unversioned=False):
+        """See InterTree.iter_changes.
+
+        This has a fast path that is only used when the from_tree matches
+        the transform tree, and no fancy options are supplied.
+        """
+        return InterTree.get(from_tree, self).iter_changes(
+            include_unchanged=include_unchanged,
+            specific_files=specific_files,
+            pb=pb,
+            extra_trees=extra_trees,
+            require_versioned=require_versioned,
+            want_unversioned=want_unversioned)
+
+    def get_file(self, path):
+        """See Tree.get_file"""
+        trans_id = self._path2trans_id(path)
+        if trans_id is None:
+            raise errors.NoSuchFile(path)
+        if trans_id in self._transform._new_contents:
+            name = self._transform._limbo_name(trans_id)
+            return open(name, 'rb')
+        if trans_id in self._transform._removed_contents:
+            raise errors.NoSuchFile(path)
+        orig_path = self._transform.tree_path(trans_id)
+        return self._transform._tree.get_file(orig_path)
+
+    def get_symlink_target(self, path):
+        """See Tree.get_symlink_target"""
+        trans_id = self._path2trans_id(path)
+        if trans_id is None:
+            raise errors.NoSuchFile(path)
+        if trans_id not in self._transform._new_contents:
+            orig_path = self._transform.tree_path(trans_id)
+            return self._transform._tree.get_symlink_target(orig_path)
+        name = self._transform._limbo_name(trans_id)
+        return osutils.readlink(name)
+
+    def annotate_iter(self, path, default_revision=_mod_revision.CURRENT_REVISION):
+        trans_id = self._path2trans_id(path)
+        if trans_id is None:
+            return None
+        orig_path = self._transform.tree_path(trans_id)
+        if orig_path is not None:
+            old_annotation = self._transform._tree.annotate_iter(
+                orig_path, default_revision=default_revision)
+        else:
+            old_annotation = []
+        try:
+            lines = self.get_file_lines(path)
+        except errors.NoSuchFile:
+            return None
+        return annotate.reannotate([old_annotation], lines, default_revision)
+
+    def get_file_text(self, path):
+        """Return the byte content of a file.
+
+        :param path: The path of the file.
+
+        :returns: A single byte string for the whole file.
+        """
+        with self.get_file(path) as my_file:
+            return my_file.read()
+
+    def get_file_lines(self, path):
+        """Return the content of a file, as lines.
+
+        :param path: The path of the file.
+        """
+        return osutils.split_lines(self.get_file_text(path))
+
+    def extras(self):
+        possible_extras = set(self._transform.trans_id_tree_path(p) for p
+                              in self._transform._tree.extras())
+        possible_extras.update(self._transform._new_contents)
+        possible_extras.update(self._transform._removed_id)
+        for trans_id in possible_extras:
+            if not self._transform.final_is_versioned(trans_id):
+                yield self._final_paths._determine_path(trans_id)
+
+    def path_content_summary(self, path):
+        trans_id = self._path2trans_id(path)
+        tt = self._transform
+        tree_path = tt.tree_path(trans_id)
+        kind = tt._new_contents.get(trans_id)
+        if kind is None:
+            if tree_path is None or trans_id in tt._removed_contents:
+                return 'missing', None, None, None
+            summary = tt._tree.path_content_summary(tree_path)
+            kind, size, executable, link_or_sha1 = summary
+        else:
+            link_or_sha1 = None
+            limbo_name = tt._limbo_name(trans_id)
+            if trans_id in tt._new_reference_revision:
+                kind = 'tree-reference'
+            if kind == 'file':
+                statval = os.lstat(limbo_name)
+                size = statval.st_size
+                if not tt._limbo_supports_executable():
+                    executable = False
+                else:
+                    executable = statval.st_mode & S_IEXEC
+            else:
+                size = None
+                executable = None
+            if kind == 'symlink':
+                link_or_sha1 = os.readlink(limbo_name)
+                if not isinstance(link_or_sha1, str):
+                    link_or_sha1 = link_or_sha1.decode(osutils._fs_enc)
+        executable = tt._new_executability.get(trans_id, executable)
+        return kind, size, executable, link_or_sha1
+
+    def get_file_mtime(self, path):
+        """See Tree.get_file_mtime"""
+        trans_id = self._path2trans_id(path)
+        if trans_id is None:
+            raise errors.NoSuchFile(path)
+        if trans_id not in self._transform._new_contents:
+            return self._transform._tree.get_file_mtime(
+                self._transform.tree_path(trans_id))
+        name = self._transform._limbo_name(trans_id)
+        statval = os.lstat(name)
+        return statval.st_mtime
+
+    def is_versioned(self, path):
+        trans_id = self._path2trans_id(path)
+        if trans_id is None:
+            # It doesn't exist, so it's not versioned.
+            return False
+        if trans_id in self._transform._versioned:
+            return True
+        if trans_id in self._transform._removed_id:
+            return False
+        orig_path = self._transform.tree_path(trans_id)
+        return self._transform._tree.is_versioned(orig_path)
+
+    def iter_entries_by_dir(self, specific_files=None, recurse_nested=False):
+        if recurse_nested:
+            raise NotImplementedError(
+                'follow tree references not yet supported')
+
+        # This may not be a maximally efficient implementation, but it is
+        # reasonably straightforward.  An implementation that grafts the
+        # TreeTransform changes onto the tree's iter_entries_by_dir results
+        # might be more efficient, but requires tricky inferences about stack
+        # position.
+        for trans_id, path in self._list_files_by_dir():
+            entry, is_versioned = self._transform.final_entry(trans_id)
+            if entry is None:
+                continue
+            if not is_versioned and entry.kind != 'directory':
+                continue
+            if specific_files is not None and path not in specific_files:
+                continue
+            if entry is not None:
+                yield path, entry
+
+    def _list_files_by_dir(self):
+        todo = [ROOT_PARENT]
+        while len(todo) > 0:
+            parent = todo.pop()
+            children = list(self._all_children(parent))
+            paths = dict(zip(children, self._final_paths.get_paths(children)))
+            children.sort(key=paths.get)
+            todo.extend(reversed(children))
+            for trans_id in children:
+                yield trans_id, paths[trans_id][0]
+
+    def revision_tree(self, revision_id):
+        return self._transform._tree.revision_tree(revision_id)
+
+    def _stat_limbo_file(self, trans_id):
+        name = self._transform._limbo_name(trans_id)
+        return os.lstat(name)
+
+    def git_snapshot(self, want_unversioned=False):
+        extra = set()
+        os = []
+        for trans_id, path in self._list_files_by_dir():
+            if not self._transform.final_is_versioned(trans_id):
+                if not want_unversioned:
+                    continue
+                extra.add(path)
+            o, mode = self._transform.final_git_entry(trans_id)
+            if o is not None:
+                self.store.add_object(o)
+                os.append((encode_git_path(path), o.id, mode))
+        if not os:
+            return None, extra
+        return commit_tree(self.store, os), extra
+
+    def iter_child_entries(self, path):
+        trans_id = self._path2trans_id(path)
+        if trans_id is None:
+            raise errors.NoSuchFile(path)
+        for child_trans_id in self._all_children(trans_id):
+            entry, is_versioned = self._transform.final_entry(trans_id)
+            if not is_versioned:
+                continue
+            if entry is not None:
+                yield entry

=== modified file 'breezy/git/tree.py'
--- breezy/git/tree.py	2020-07-18 23:14:00 +0000
+++ breezy/git/tree.py	2020-08-23 01:05:31 +0000
@@ -76,18 +76,17 @@
     TransportObjectStore,
     TransportRepo,
     )
+from ..bzr.inventorytree import InventoryTreeChange
 
 
 class GitTreeDirectory(_mod_tree.TreeDirectory):
 
-    __slots__ = ['file_id', 'name', 'parent_id', 'children']
+    __slots__ = ['file_id', 'name', 'parent_id']
 
     def __init__(self, file_id, name, parent_id):
         self.file_id = file_id
         self.name = name
         self.parent_id = parent_id
-        # TODO(jelmer)
-        self.children = {}
 
     @property
     def kind(self):
@@ -115,16 +114,16 @@
 
 class GitTreeFile(_mod_tree.TreeFile):
 
-    __slots__ = ['file_id', 'name', 'parent_id', 'text_size', 'text_sha1',
-                 'executable']
+    __slots__ = ['file_id', 'name', 'parent_id', 'text_size',
+                 'executable', 'git_sha1']
 
     def __init__(self, file_id, name, parent_id, text_size=None,
-                 text_sha1=None, executable=None):
+                 git_sha1=None, executable=None):
         self.file_id = file_id
         self.name = name
         self.parent_id = parent_id
         self.text_size = text_size
-        self.text_sha1 = text_sha1
+        self.git_sha1 = git_sha1
         self.executable = executable
 
     @property
@@ -136,20 +135,20 @@
                 self.file_id == other.file_id and
                 self.name == other.name and
                 self.parent_id == other.parent_id and
-                self.text_sha1 == other.text_sha1 and
+                self.git_sha1 == other.git_sha1 and
                 self.text_size == other.text_size and
                 self.executable == other.executable)
 
     def __repr__(self):
         return ("%s(file_id=%r, name=%r, parent_id=%r, text_size=%r, "
-                "text_sha1=%r, executable=%r)") % (
+                "git_sha1=%r, executable=%r)") % (
             type(self).__name__, self.file_id, self.name, self.parent_id,
-            self.text_size, self.text_sha1, self.executable)
+            self.text_size, self.git_sha1, self.executable)
 
     def copy(self):
         ret = self.__class__(
             self.file_id, self.name, self.parent_id)
-        ret.text_sha1 = self.text_sha1
+        ret.git_sha1 = self.git_sha1
         ret.text_size = self.text_size
         ret.executable = self.executable
         return ret
@@ -257,7 +256,57 @@
     return path
 
 
-class GitRevisionTree(revisiontree.RevisionTree):
+class GitTree(_mod_tree.Tree):
+
+    def iter_git_objects(self):
+        """Iterate over all the objects in the tree.
+
+        :return :Yields tuples with (path, sha, mode)
+        """
+        raise NotImplementedError(self.iter_git_objects)
+
+    def git_snapshot(self, want_unversioned=False):
+        """Snapshot a tree, and return tree object.
+
+        :return: Tree sha and set of extras
+        """
+        raise NotImplementedError(self.snapshot)
+
+    def preview_transform(self, pb=None):
+        from .transform import GitTransformPreview
+        return GitTransformPreview(self, pb=pb)
+
+    def find_related_paths_across_trees(self, paths, trees=[],
+                                        require_versioned=True):
+        if paths is None:
+            return None
+        if require_versioned:
+            trees = [self] + (trees if trees is not None else [])
+            unversioned = set()
+            for p in paths:
+                for t in trees:
+                    if t.is_versioned(p):
+                        break
+                else:
+                    unversioned.add(p)
+            if unversioned:
+                raise errors.PathsNotVersionedError(unversioned)
+        return filter(self.is_versioned, paths)
+
+    def _submodule_info(self):
+        if self._submodules is None:
+            try:
+                with self.get_file('.gitmodules') as f:
+                    config = GitConfigFile.from_file(f)
+                    self._submodules = {
+                        path: (url, section)
+                        for path, url, section in parse_submodules(config)}
+            except errors.NoSuchFile:
+                self._submodules = {}
+        return self._submodules
+
+
+class GitRevisionTree(revisiontree.RevisionTree, GitTree):
     """Revision tree implementation based on Git objects."""
 
     def __init__(self, repository, revision_id):
@@ -279,17 +328,8 @@
                 raise errors.NoSuchRevision(repository, revision_id)
             self.tree = commit.tree
 
-    def _submodule_info(self):
-        if self._submodules is None:
-            try:
-                with self.get_file('.gitmodules') as f:
-                    config = GitConfigFile.from_file(f)
-                    self._submodules = {
-                        path: (url, section)
-                        for path, url, section in parse_submodules(config)}
-            except errors.NoSuchFile:
-                self._submodules = {}
-        return self._submodules
+    def git_snapshot(self, want_unversioned=False):
+        return self.tree, set()
 
     def _get_submodule_repository(self, relpath):
         if not isinstance(relpath, bytes):
@@ -421,18 +461,6 @@
         else:
             return True
 
-    def _submodule_info(self):
-        if self._submodules is None:
-            try:
-                with self.get_file('.gitmodules') as f:
-                    config = GitConfigFile.from_file(f)
-                    self._submodules = {
-                        path: (url, section)
-                        for path, url, section in parse_submodules(config)}
-            except errors.NoSuchFile:
-                self._submodules = {}
-        return self._submodules
-
     def list_files(self, include_root=False, from_dir=None, recursive=True,
                    recurse_nested=False):
         if self.tree is None:
@@ -496,9 +524,8 @@
             ie.reference_revision = self.mapping.revision_id_foreign_to_bzr(
                 hexsha)
         else:
-            data = store[hexsha].data
-            ie.text_sha1 = osutils.sha_string(data)
-            ie.text_size = len(data)
+            ie.git_sha1 = hexsha
+            ie.text_size = None
             ie.executable = mode_is_executable(mode)
         return ie
 
@@ -649,23 +676,6 @@
         else:
             return (kind, None, None, None)
 
-    def find_related_paths_across_trees(self, paths, trees=[],
-                                        require_versioned=True):
-        if paths is None:
-            return None
-        if require_versioned:
-            trees = [self] + (trees if trees is not None else [])
-            unversioned = set()
-            for p in paths:
-                for t in trees:
-                    if t.is_versioned(p):
-                        break
-                else:
-                    unversioned.add(p)
-            if unversioned:
-                raise errors.PathsNotVersionedError(unversioned)
-        return filter(self.is_versioned, paths)
-
     def _iter_tree_contents(self, include_trees=False):
         if self.tree is None:
             return iter([])
@@ -699,9 +709,9 @@
     def walkdirs(self, prefix=u""):
         (store, mode, hexsha) = self._lookup_path(prefix)
         todo = deque(
-            [(store, encode_git_path(prefix), hexsha, self.path2id(prefix))])
+            [(store, encode_git_path(prefix), hexsha)])
         while todo:
-            store, path, tree_sha, parent_id = todo.popleft()
+            store, path, tree_sha = todo.popleft()
             path_decoded = decode_git_path(path)
             tree = store[tree_sha]
             children = []
@@ -709,18 +719,13 @@
                 if self.mapping.is_special_file(name):
                     continue
                 child_path = posixpath.join(path, name)
-                file_id = self.path2id(decode_git_path(child_path))
                 if stat.S_ISDIR(mode):
-                    todo.append((store, child_path, hexsha, file_id))
+                    todo.append((store, child_path, hexsha))
                 children.append(
                     (decode_git_path(child_path), decode_git_path(name),
                         mode_kind(mode), None,
-                        file_id, mode_kind(mode)))
-            yield (path_decoded, parent_id), children
-
-    def preview_transform(self, pb=None):
-        from .transform import GitTransformPreview
-        return GitTransformPreview(self, pb=pb)
+                        mode_kind(mode)))
+            yield path_decoded, children
 
 
 def tree_delta_from_git_changes(changes, mappings,
@@ -814,7 +819,7 @@
             newpath = None
         if oldpath is None and newpath is None:
             continue
-        change = _mod_tree.TreeChange(
+        change = InventoryTreeChange(
             fileid, (oldpath_decoded, newpath_decoded), (oldsha != newsha),
             (oldversioned, newversioned),
             (oldparent, newparent), (oldname, newname),
@@ -860,7 +865,7 @@
         parent_id = new_mapping.generate_file_id(parent_path)
         file_id = new_mapping.generate_file_id(path_decoded)
         ret.added.append(
-            _mod_tree.TreeChange(
+            InventoryTreeChange(
                 file_id, (None, path_decoded), True,
                 (False, True),
                 (None, parent_id),
@@ -956,8 +961,13 @@
             fileid = mapping.generate_file_id(newpath_decoded)
         else:
             fileid = None
-        yield _mod_tree.TreeChange(
-            fileid, (oldpath_decoded, newpath_decoded), (oldsha != newsha),
+        if oldkind == 'directory' and newkind == 'directory':
+            modified = False
+        else:
+            modified = (oldsha != newsha) or (oldmode != newmode)
+        yield InventoryTreeChange(
+            fileid, (oldpath_decoded, newpath_decoded),
+            modified,
             (oldversioned, newversioned),
             (oldparent, newparent), (oldname, newname),
             (oldkind, newkind), (oldexe, newexe),
@@ -971,10 +981,18 @@
     _matching_to_tree_format = None
     _test_mutable_trees_to_test_trees = None
 
+    def __init__(self, source, target):
+        super(InterGitTrees, self).__init__(source, target)
+        if self.source.store == self.target.store:
+            self.store = self.source.store
+        else:
+            self.store = OverlayObjectStore(
+                [self.source.store, self.target.store])
+        self.rename_detector = RenameDetector(self.store)
+
     @classmethod
     def is_compatible(cls, source, target):
-        return (isinstance(source, GitRevisionTree) and
-                isinstance(target, GitRevisionTree))
+        return isinstance(source, GitTree) and isinstance(target, GitTree)
 
     def compare(self, want_unchanged=False, specific_files=None,
                 extra_trees=None, require_versioned=False, include_root=False,
@@ -1012,7 +1030,25 @@
     def _iter_git_changes(self, want_unchanged=False, specific_files=None,
                           require_versioned=False, extra_trees=None,
                           want_unversioned=False, include_trees=True):
-        raise NotImplementedError(self._iter_git_changes)
+        trees = [self.source]
+        if extra_trees is not None:
+            trees.extend(extra_trees)
+        if specific_files is not None:
+            specific_files = self.target.find_related_paths_across_trees(
+                specific_files, trees,
+                require_versioned=require_versioned)
+        # TODO(jelmer): Restrict to specific_files, for performance reasons.
+        with self.lock_read():
+            from_tree_sha, from_extras = self.source.git_snapshot(
+                want_unversioned=want_unversioned)
+            to_tree_sha, to_extras = self.target.git_snapshot(
+                want_unversioned=want_unversioned)
+            changes = tree_changes(
+                self.store, from_tree_sha, to_tree_sha,
+                include_trees=include_trees,
+                rename_detector=self.rename_detector,
+                want_unchanged=want_unchanged, change_type_same=True)
+            return changes, from_extras, to_extras
 
     def find_target_path(self, path, recurse='none'):
         ret = self.find_target_paths([path], recurse=recurse)
@@ -1067,48 +1103,10 @@
         return ret
 
 
-class InterGitRevisionTrees(InterGitTrees):
-    """InterTree that works between two git revision trees."""
-
-    _matching_from_tree_format = None
-    _matching_to_tree_format = None
-    _test_mutable_trees_to_test_trees = None
-
-    @classmethod
-    def is_compatible(cls, source, target):
-        return (isinstance(source, GitRevisionTree) and
-                isinstance(target, GitRevisionTree))
-
-    def _iter_git_changes(self, want_unchanged=False, specific_files=None,
-                          require_versioned=True, extra_trees=None,
-                          want_unversioned=False, include_trees=True):
-        trees = [self.source]
-        if extra_trees is not None:
-            trees.extend(extra_trees)
-        if specific_files is not None:
-            specific_files = self.target.find_related_paths_across_trees(
-                specific_files, trees,
-                require_versioned=require_versioned)
-
-        if (self.source._repository._git.object_store !=
-                self.target._repository._git.object_store):
-            store = OverlayObjectStore(
-                [self.source._repository._git.object_store,
-                    self.target._repository._git.object_store])
-        else:
-            store = self.source._repository._git.object_store
-        rename_detector = RenameDetector(store)
-        changes = tree_changes(
-            store, self.source.tree, self.target.tree,
-            want_unchanged=want_unchanged, include_trees=include_trees,
-            change_type_same=True, rename_detector=rename_detector)
-        return changes, set(), set()
-
-
-_mod_tree.InterTree.register_optimiser(InterGitRevisionTrees)
-
-
-class MutableGitIndexTree(mutabletree.MutableTree):
+_mod_tree.InterTree.register_optimiser(InterGitTrees)
+
+
+class MutableGitIndexTree(mutabletree.MutableTree, GitTree):
 
     def __init__(self):
         self._lock_mode = None
@@ -1117,6 +1115,9 @@
         self._index_dirty = False
         self._submodules = None
 
+    def git_snapshot(self, want_unversioned=False):
+        return snapshot_workingtree(self, want_unversioned=want_unversioned)
+
     def is_versioned(self, path):
         with self.lock_read():
             path = encode_git_path(path.rstrip('/'))
@@ -1136,7 +1137,7 @@
         if self._lock_mode is None:
             raise errors.ObjectNotLocked(self)
         self._versioned_dirs = set()
-        for p, i in self._recurse_index_entries():
+        for p, sha, mode in self.iter_git_objects():
             self._ensure_versioned_dir(posixpath.dirname(p))
 
     def _ensure_versioned_dir(self, dirname):
@@ -1185,18 +1186,6 @@
     def _read_submodule_head(self, path):
         raise NotImplementedError(self._read_submodule_head)
 
-    def _submodule_info(self):
-        if self._submodules is None:
-            try:
-                with self.get_file('.gitmodules') as f:
-                    config = GitConfigFile.from_file(f)
-                    self._submodules = {
-                        path: (url, section)
-                        for path, url, section in parse_submodules(config)}
-            except errors.NoSuchFile:
-                self._submodules = {}
-        return self._submodules
-
     def _lookup_index(self, encoded_path):
         if not isinstance(encoded_path, bytes):
             raise TypeError(encoded_path)
@@ -1232,11 +1221,32 @@
         # TODO(jelmer): Keep track of dirty per index
         self._index_dirty = True
 
-    def _index_add_entry(self, path, kind, flags=0, reference_revision=None):
+    def _apply_index_changes(self, changes):
+        for (path, kind, executability, reference_revision,
+             symlink_target) in changes:
+            if kind is None or kind == 'directory':
+                (index, subpath) = self._lookup_index(
+                    encode_git_path(path))
+                try:
+                    self._index_del_entry(index, subpath)
+                except KeyError:
+                    pass
+                else:
+                    self._versioned_dirs = None
+            else:
+                self._index_add_entry(
+                    path, kind,
+                    reference_revision=reference_revision,
+                    symlink_target=symlink_target)
+        self.flush()
+
+    def _index_add_entry(
+            self, path, kind, flags=0, reference_revision=None,
+            symlink_target=None):
         if kind == "directory":
             # Git indexes don't contain directories
             return
-        if kind == "file":
+        elif kind == "file":
             blob = Blob()
             try:
                 file, stat_val = self.get_file_with_stat(path)
@@ -1261,7 +1271,9 @@
                 # old index
                 stat_val = os.stat_result(
                     (stat.S_IFLNK, 0, 0, 0, 0, 0, 0, 0, 0, 0))
-            blob.set_raw_string(encode_git_path(self.get_symlink_target(path)))
+            if symlink_target is None:
+                symlink_target = self.get_symlink_target(path)
+            blob.set_raw_string(encode_git_path(symlink_target))
             # Add object to the repository if it didn't exist yet
             if blob.id not in self.store:
                 self.store.add_object(blob)
@@ -1295,6 +1307,10 @@
         if self._versioned_dirs is not None:
             self._ensure_versioned_dir(index_path)
 
+    def iter_git_objects(self):
+        for p, entry in self._recurse_index_entries():
+            yield p, entry.sha, entry.mode
+
     def _recurse_index_entries(self, index=None, basepath=b"",
                                recurse_nested=False):
         # Iterate over all index entries
@@ -1381,18 +1397,8 @@
         elif kind == 'tree-reference':
             ie.reference_revision = self.get_reference_revision(path)
         else:
-            try:
-                data = self.get_file_text(path)
-            except errors.NoSuchFile:
-                data = None
-            except IOError as e:
-                if e.errno != errno.ENOENT:
-                    raise
-                data = None
-            if data is None:
-                data = self.branch.repository._git.object_store[sha].data
-            ie.text_sha1 = osutils.sha_string(data)
-            ie.text_size = len(data)
+            ie.git_sha1 = sha
+            ie.text_size = size
             ie.executable = bool(stat.S_ISREG(mode) and stat.S_IEXEC & mode)
         return ie
 
@@ -1559,25 +1565,6 @@
             self._versioned_dirs = None
             self.flush()
 
-    def find_related_paths_across_trees(self, paths, trees=[],
-                                        require_versioned=True):
-        if paths is None:
-            return None
-
-        if require_versioned:
-            trees = [self] + (trees if trees is not None else [])
-            unversioned = set()
-            for p in paths:
-                for t in trees:
-                    if t.is_versioned(p):
-                        break
-                else:
-                    unversioned.add(p)
-            if unversioned:
-                raise errors.PathsNotVersionedError(unversioned)
-
-        return filter(self.is_versioned, paths)
-
     def path_content_summary(self, path):
         """See Tree.path_content_summary."""
         try:
@@ -1604,17 +1591,21 @@
             return (kind, None, None, None)
 
     def stored_kind(self, relpath):
+        if relpath == '':
+            return 'directory'
         (index, index_path) = self._lookup_index(encode_git_path(relpath))
         if index is None:
-            return kind
+            return None
         try:
             mode = index[index_path].mode
         except KeyError:
-            return kind
+            for p in index:
+                if osutils.is_inside(
+                        decode_git_path(index_path), decode_git_path(p)):
+                    return 'directory'
+            return None
         else:
-            if S_ISGITLINK(mode):
-                return 'tree-reference'
-            return 'directory'
+            return mode_kind(mode)
 
     def kind(self, relpath):
         kind = osutils.file_kind(self.abspath(relpath))
@@ -1632,134 +1623,49 @@
         from .transform import GitTreeTransform
         return GitTreeTransform(self, pb=pb)
 
-    def preview_transform(self, pb=None):
-        from .transform import GitTransformPreview
-        return GitTransformPreview(self, pb=pb)
-
-
-class InterToIndexGitTree(InterGitTrees):
-    """InterTree that works between a Git revision tree and an index."""
-
-    def __init__(self, source, target):
-        super(InterToIndexGitTree, self).__init__(source, target)
-        if self.source.store == self.target.store:
-            self.store = self.source.store
-        else:
-            self.store = OverlayObjectStore(
-                [self.source.store, self.target.store])
-        self.rename_detector = RenameDetector(self.store)
-
-    @classmethod
-    def is_compatible(cls, source, target):
-        return (isinstance(source, GitRevisionTree) and
-                isinstance(target, MutableGitIndexTree))
-
-    def _iter_git_changes(self, want_unchanged=False, specific_files=None,
-                          require_versioned=False, extra_trees=None,
-                          want_unversioned=False, include_trees=True):
-        trees = [self.source]
-        if extra_trees is not None:
-            trees.extend(extra_trees)
-        if specific_files is not None:
-            specific_files = self.target.find_related_paths_across_trees(
-                specific_files, trees,
-                require_versioned=require_versioned)
-        # TODO(jelmer): Restrict to specific_files, for performance reasons.
-        with self.lock_read():
-            changes, target_extras = changes_between_git_tree_and_working_copy(
-                self.source.store, self.source.tree,
-                self.target, want_unchanged=want_unchanged,
-                want_unversioned=want_unversioned,
-                rename_detector=self.rename_detector,
-                include_trees=include_trees)
-            return changes, set(), target_extras
-
-
-_mod_tree.InterTree.register_optimiser(InterToIndexGitTree)
-
-
-class InterFromIndexGitTree(InterGitTrees):
-    """InterTree that works between a Git revision tree and an index."""
-
-    def __init__(self, source, target):
-        super(InterFromIndexGitTree, self).__init__(source, target)
-        if self.source.store == self.target.store:
-            self.store = self.source.store
-        else:
-            self.store = OverlayObjectStore(
-                [self.source.store, self.target.store])
-        self.rename_detector = RenameDetector(self.store)
-
-    @classmethod
-    def is_compatible(cls, source, target):
-        return (isinstance(target, GitRevisionTree) and
-                isinstance(source, MutableGitIndexTree))
-
-    def _iter_git_changes(self, want_unchanged=False, specific_files=None,
-                          require_versioned=False, extra_trees=None,
-                          want_unversioned=False, include_trees=True):
-        trees = [self.source]
-        if extra_trees is not None:
-            trees.extend(extra_trees)
-        if specific_files is not None:
-            specific_files = self.target.find_related_paths_across_trees(
-                specific_files, trees,
-                require_versioned=require_versioned)
-        # TODO(jelmer): Restrict to specific_files, for performance reasons.
-        with self.lock_read():
-            from_tree_sha, extras = snapshot_workingtree(self.source, want_unversioned=want_unversioned)
-            return tree_changes(
-                self.store, from_tree_sha, self.target.tree,
-                include_trees=include_trees,
-                rename_detector=self.rename_detector,
-                want_unchanged=want_unchanged, change_type_same=True), extras
-
-
-_mod_tree.InterTree.register_optimiser(InterFromIndexGitTree)
-
-
-class InterIndexGitTree(InterGitTrees):
-    """InterTree that works between a Git revision tree and an index."""
-
-    def __init__(self, source, target):
-        super(InterIndexGitTree, self).__init__(source, target)
-        if self.source.store == self.target.store:
-            self.store = self.source.store
-        else:
-            self.store = OverlayObjectStore(
-                [self.source.store, self.target.store])
-        self.rename_detector = RenameDetector(self.store)
-
-    @classmethod
-    def is_compatible(cls, source, target):
-        return (isinstance(target, MutableGitIndexTree) and
-                isinstance(source, MutableGitIndexTree))
-
-    def _iter_git_changes(self, want_unchanged=False, specific_files=None,
-                          require_versioned=False, extra_trees=None,
-                          want_unversioned=False, include_trees=True):
-        trees = [self.source]
-        if extra_trees is not None:
-            trees.extend(extra_trees)
-        if specific_files is not None:
-            specific_files = self.target.find_related_paths_across_trees(
-                specific_files, trees,
-                require_versioned=require_versioned)
-        # TODO(jelmer): Restrict to specific_files, for performance reasons.
-        with self.lock_read():
-            from_tree_sha, from_extras = snapshot_workingtree(
-                self.source, want_unversioned=want_unversioned)
-            to_tree_sha, to_extras = snapshot_workingtree(
-                self.target, want_unversioned=want_unversioned)
-            changes = tree_changes(
-                self.store, from_tree_sha, to_tree_sha,
-                include_trees=include_trees,
-                rename_detector=self.rename_detector,
-                want_unchanged=want_unchanged, change_type_same=True)
-            return changes, from_extras, to_extras
-
-
-_mod_tree.InterTree.register_optimiser(InterIndexGitTree)
+    def has_changes(self, _from_tree=None):
+        """Quickly check that the tree contains at least one commitable change.
+
+        :param _from_tree: tree to compare against to find changes (default to
+            the basis tree and is intended to be used by tests).
+
+        :return: True if a change is found. False otherwise
+        """
+        with self.lock_read():
+            # Check pending merges
+            if len(self.get_parent_ids()) > 1:
+                return True
+            if _from_tree is None:
+                _from_tree = self.basis_tree()
+            changes = self.iter_changes(_from_tree)
+            if self.supports_symlinks():
+                # Fast path for has_changes.
+                try:
+                    change = next(changes)
+                    if change.path[1] == '':
+                        next(changes)
+                    return True
+                except StopIteration:
+                    # No changes
+                    return False
+            else:
+                # Slow path for has_changes.
+                # Handle platforms that do not support symlinks in the
+                # conditional below. This is slower than the try/except
+                # approach below that but we don't have a choice as we
+                # need to be sure that all symlinks are removed from the
+                # entire changeset. This is because in platforms that
+                # do not support symlinks, they show up as None in the
+                # working copy as compared to the repository.
+                # Also, exclude root as mention in the above fast path.
+                changes = filter(
+                    lambda c: c[6][0] != 'symlink' and c[4] != (None, None),
+                    changes)
+                try:
+                    next(iter(changes))
+                except StopIteration:
+                    return False
+                return True
 
 
 def snapshot_workingtree(target, want_unversioned=False):
@@ -1809,21 +1715,21 @@
                         target.store.add_object(blob)
                 blobs[path] = (live_entry.sha, cleanup_mode(live_entry.mode))
     if want_unversioned:
-        for e in target._iter_files_recursive(include_dirs=False):
+        for extra in target._iter_files_recursive(include_dirs=False):
             try:
-                e, accessible = osutils.normalized_filename(e)
+                extra, accessible = osutils.normalized_filename(extra)
             except UnicodeDecodeError:
                 raise errors.BadFilenameEncoding(
-                    e, osutils._fs_enc)
-            np = encode_git_path(e)
+                    extra, osutils._fs_enc)
+            np = encode_git_path(extra)
             if np in blobs:
                 continue
-            st = target._lstat(e)
+            st = target._lstat(extra)
             if stat.S_ISDIR(st.st_mode):
                 blob = Tree()
             elif stat.S_ISREG(st.st_mode) or stat.S_ISLNK(st.st_mode):
                 blob = blob_from_path_and_stat(
-                    target.abspath(e).encode(osutils._fs_enc), st)
+                    target.abspath(extra).encode(osutils._fs_enc), st)
             else:
                 continue
             target.store.add_object(blob)
@@ -1831,19 +1737,3 @@
             extras.add(np)
     return commit_tree(
         target.store, dirified + [(p, s, m) for (p, (s, m)) in blobs.items()]), extras
-
-
-def changes_between_git_tree_and_working_copy(source_store, from_tree_sha, target,
-                                              want_unchanged=False,
-                                              want_unversioned=False,
-                                              rename_detector=None,
-                                              include_trees=True):
-    """Determine the changes between a git tree and a working tree with index.
-
-    """
-    to_tree_sha, extras = snapshot_workingtree(target, want_unversioned=want_unversioned)
-    store = OverlayObjectStore([source_store, target.store])
-    return tree_changes(
-        store, from_tree_sha, to_tree_sha, include_trees=include_trees,
-        rename_detector=rename_detector,
-        want_unchanged=want_unchanged, change_type_same=True), extras

=== modified file 'breezy/git/workingtree.py'
--- breezy/git/workingtree.py	2020-07-18 23:14:00 +0000
+++ breezy/git/workingtree.py	2020-08-23 01:05:31 +0000
@@ -44,6 +44,7 @@
     )
 import os
 import posixpath
+import re
 import stat
 import sys
 
@@ -84,6 +85,101 @@
     )
 
 
+CONFLICT_SUFFIXES = ['.BASE', '.OTHER', '.THIS']
+
+
+# TODO: There should be a base revid attribute to better inform the user about
+# how the conflicts were generated.
+class TextConflict(_mod_conflicts.Conflict):
+    """The merge algorithm could not resolve all differences encountered."""
+
+    has_files = True
+
+    typestring = 'text conflict'
+
+    _conflict_re = re.compile(b'^(<{7}|={7}|>{7})')
+
+    def associated_filenames(self):
+        return [self.path + suffix for suffix in CONFLICT_SUFFIXES]
+
+    def _resolve(self, tt, winner_suffix):
+        """Resolve the conflict by copying one of .THIS or .OTHER into file.
+
+        :param tt: The TreeTransform where the conflict is resolved.
+        :param winner_suffix: Either 'THIS' or 'OTHER'
+
+        The resolution is symmetric, when taking THIS, item.THIS is renamed
+        into item and vice-versa. This takes one of the files as a whole
+        ignoring every difference that could have been merged cleanly.
+        """
+        # To avoid useless copies, we switch item and item.winner_suffix, only
+        # item will exist after the conflict has been resolved anyway.
+        item_tid = tt.trans_id_tree_path(self.path)
+        item_parent_tid = tt.get_tree_parent(item_tid)
+        winner_path = self.path + '.' + winner_suffix
+        winner_tid = tt.trans_id_tree_path(winner_path)
+        winner_parent_tid = tt.get_tree_parent(winner_tid)
+        # Switch the paths to preserve the content
+        tt.adjust_path(osutils.basename(self.path),
+                       winner_parent_tid, winner_tid)
+        tt.adjust_path(osutils.basename(winner_path),
+                       item_parent_tid, item_tid)
+        tt.unversion_file(item_tid)
+        tt.version_file(winner_tid)
+        tt.apply()
+
+    def action_auto(self, tree):
+        # GZ 2012-07-27: Using NotImplementedError to signal that a conflict
+        #                can't be auto resolved does not seem ideal.
+        try:
+            kind = tree.kind(self.path)
+        except errors.NoSuchFile:
+            return
+        if kind != 'file':
+            raise NotImplementedError("Conflict is not a file")
+        conflict_markers_in_line = self._conflict_re.search
+        with tree.get_file(self.path) as f:
+            for line in f:
+                if conflict_markers_in_line(line):
+                    raise NotImplementedError("Conflict markers present")
+
+    def _resolve_with_cleanups(self, tree, *args, **kwargs):
+        with tree.transform() as tt:
+            self._resolve(tt, *args, **kwargs)
+
+    def action_take_this(self, tree):
+        self._resolve_with_cleanups(tree, 'THIS')
+
+    def action_take_other(self, tree):
+        self._resolve_with_cleanups(tree, 'OTHER')
+
+    def do(self, action, tree):
+        """Apply the specified action to the conflict.
+
+        :param action: The method name to call.
+
+        :param tree: The tree passed as a parameter to the method.
+        """
+        meth = getattr(self, 'action_%s' % action, None)
+        if meth is None:
+            raise NotImplementedError(self.__class__.__name__ + '.' + action)
+        meth(tree)
+
+    def action_done(self, tree):
+        """Mark the conflict as solved once it has been handled."""
+        # This method does nothing but simplifies the design of upper levels.
+        pass
+
+    def describe(self):
+        return 'Text conflict in %(path)s' % self.__dict__
+
+    def __str__(self):
+        return self.describe()
+
+    def __repr__(self):
+        return "%s(%r)" % (type(self).__name__, self.path)
+
+
 class GitWorkingTree(MutableGitIndexTree, workingtree.WorkingTree):
     """A Git working tree."""
 
@@ -330,8 +426,8 @@
         def recurse_directory_to_add_files(directory):
             # Recurse directory and add all files
             # so we can check if they have changed.
-            for parent_info, file_infos in self.walkdirs(directory):
-                for relpath, basename, kind, lstat, fileid, kind in file_infos:
+            for parent_path, file_infos in self.walkdirs(directory):
+                for relpath, basename, kind, lstat, kind in file_infos:
                     # Is it versioned or ignored?
                     if self.is_versioned(relpath):
                         # Add nested content for deletion.
@@ -569,7 +665,7 @@
         """
         with self.lock_read():
             index_paths = set(
-                [decode_git_path(p) for p, i in self._recurse_index_entries()])
+                [decode_git_path(p) for p, sha, mode in self.iter_git_objects()])
             all_paths = set(self._iter_files_recursive(include_dirs=False))
             return iter(all_paths - index_paths)
 
@@ -867,8 +963,7 @@
             conflicts = _mod_conflicts.ConflictList()
             for item_path, value in self.index.iteritems():
                 if value.flags & FLAG_STAGEMASK:
-                    conflicts.append(_mod_conflicts.TextConflict(
-                        decode_git_path(item_path)))
+                    conflicts.append(TextConflict(decode_git_path(item_path)))
             return conflicts
 
     def set_conflicts(self, conflicts):
@@ -883,7 +978,6 @@
                 self._set_conflicted(path, path in by_path)
 
     def _set_conflicted(self, path, conflicted):
-        trace.mutter('change conflict: %r -> %r', path, conflicted)
         value = self.index[path]
         self._index_dirty = True
         if conflicted:
@@ -909,8 +1003,8 @@
         """Walk the directories of this tree.
 
         returns a generator which yields items in the form:
-                ((curren_directory_path, fileid),
-                 [(file1_path, file1_name, file1_kind, (lstat), file1_id,
+                (current_directory_path,
+                 [(file1_path, file1_name, file1_kind, (lstat),
                    file1_kind), ... ])
 
         This API returns a generator, which is only valid during the current
@@ -974,20 +1068,20 @@
                              - (current_inv[0][0] < cur_disk_dir_relpath))
             if direction > 0:
                 # disk is before inventory - unknown
-                dirblock = [(relpath, basename, kind, stat, None, None) for
+                dirblock = [(relpath, basename, kind, stat, None) for
                             relpath, basename, kind, stat, top_path in
                             cur_disk_dir_content]
-                yield (cur_disk_dir_relpath, None), dirblock
+                yield cur_disk_dir_relpath, dirblock
                 try:
                     current_disk = next(disk_iterator)
                 except StopIteration:
                     disk_finished = True
             elif direction < 0:
                 # inventory is before disk - missing.
-                dirblock = [(relpath, basename, 'unknown', None, fileid, kind)
+                dirblock = [(relpath, basename, 'unknown', None, kind)
                             for relpath, basename, dkind, stat, fileid, kind in
                             current_inv[1]]
-                yield (current_inv[0][0], current_inv[0][1]), dirblock
+                yield current_inv[0][0], dirblock
                 try:
                     current_inv = next(inventory_iterator)
                 except StopIteration:
@@ -1005,23 +1099,22 @@
                         # versioned, present file
                         dirblock.append((inv_row[0],
                                          inv_row[1], disk_row[2],
-                                         disk_row[3], inv_row[4],
-                                         inv_row[5]))
+                                         disk_row[3], inv_row[5]))
                     elif len(path_elements[0]) == 5:
                         # unknown disk file
                         dirblock.append(
                             (path_elements[0][0], path_elements[0][1],
                                 path_elements[0][2], path_elements[0][3],
-                                None, None))
+                                None))
                     elif len(path_elements[0]) == 6:
                         # versioned, absent file.
                         dirblock.append(
                             (path_elements[0][0], path_elements[0][1],
-                                'unknown', None, path_elements[0][4],
+                                'unknown', None,
                                 path_elements[0][5]))
                     else:
                         raise NotImplementedError('unreachable code')
-                yield current_inv[0], dirblock