Merge lp:~jelmer/brz/objects-1 into lp:brz

[Jelmer Vernooij]

Use the new attributes on TreeChange rather than indexing.

Use the new attributes on TreeChange rather than indexing.

[Martin Packman (gz)]

Thanks! As discussed, probably makes sense to flatten this a bit more in future, but this is much more readable as is.

review: Approve

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

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

=== modified file 'breezy/builtins.py'
--- breezy/builtins.py	2019-06-02 03:11:13 +0000
+++ breezy/builtins.py	2019-06-15 17:35:57 +0000
@@ -1701,12 +1701,12 @@
         self.add_cleanup(old_tree.lock_read().unlock)
         renames = []
         iterator = tree.iter_changes(old_tree, include_unchanged=True)
-        for f, paths, c, v, p, n, k, e in iterator:
-            if paths[0] == paths[1]:
-                continue
-            if None in (paths):
-                continue
-            renames.append(paths)
+        for change in iterator:
+            if change.path[0] == change.path[1]:
+                continue
+            if None in change.path:
+                continue
+            renames.append(change.path)
         renames.sort()
         for old_name, new_name in renames:
             self.outf.write("%s => %s\n" % (old_name, new_name))
@@ -1916,8 +1916,8 @@
             missing = []
             for change in tree.iter_changes(tree.basis_tree()):
                 # Find paths in the working tree that have no kind:
-                if change[1][1] is not None and change[6][1] is None:
-                    missing.append(change[1][1])
+                if change.path[1] is not None and change.kind[1] is None:
+                    missing.append(change.path[1])
             file_list = sorted(missing, reverse=True)
             file_deletion_strategy = 'keep'
         tree.remove(file_list, verbose=verbose, to_file=self.outf,
 
=== modified file 'breezy/bzr/_dirstate_helpers_pyx.pyx'
--- breezy/bzr/_dirstate_helpers_pyx.pyx	2019-06-15 01:02:49 +0000
+++ breezy/bzr/_dirstate_helpers_pyx.pyx	2019-06-15 17:35:57 +0000
@@ -1553,7 +1553,8 @@
                 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 (None,
+                return TreeChange(
+                       None,
                        (None, self.current_root_unicode),
                        True,
                        (False, False),
@@ -1664,7 +1665,8 @@
                             new_executable = bool(
                                 stat.S_ISREG(current_path_info[3].st_mode)
                                 and stat.S_IEXEC & current_path_info[3].st_mode)
-                            return (None,
+                            return TreeChange(
+                                None,
                                 (None, self.utf8_decode(current_path_info[0])[0]),
                                 True,
                                 (False, False),
@@ -1833,7 +1835,8 @@
                             if changed is not None:
                                 raise AssertionError(
                                     "result is not None: %r" % result)
-                            result = (None,
+                            result = TreeChange(
+                                None,
                                 (None, relpath_unicode),
                                 True,
                                 (False, False),
 
=== modified file 'breezy/bzr/dirstate.py'
--- breezy/bzr/dirstate.py	2019-06-15 01:02:49 +0000
+++ breezy/bzr/dirstate.py	2019-06-15 17:35:57 +0000
@@ -4190,15 +4190,15 @@
                                 except UnicodeDecodeError:
                                     raise errors.BadFilenameEncoding(
                                         current_path_info[0], osutils._fs_enc)
-                                yield (None,
-                                       (None, relpath_unicode),
-                                       True,
-                                       (False, False),
-                                       (None, None),
-                                       (None, utf8_decode(
-                                        current_path_info[1])[0]),
-                                       (None, current_path_info[2]),
-                                       (None, new_executable))
+                                yield TreeChange(
+                                    None,
+                                    (None, relpath_unicode),
+                                    True,
+                                    (False, False),
+                                    (None, None),
+                                    (None, utf8_decode(current_path_info[1])[0]),
+                                    (None, current_path_info[2]),
+                                    (None, new_executable))
                             # dont descend into this unversioned path if it is
                             # a dir
                             if current_path_info[2] in ('directory'):
 
=== modified file 'breezy/bzr/inventory.py'
--- breezy/bzr/inventory.py	2019-06-15 13:33:16 +0000
+++ breezy/bzr/inventory.py	2019-06-15 17:35:57 +0000
@@ -2104,8 +2104,9 @@
                 # Could happen when only the revision changed for a directory
                 # for instance.
                 continue
-            yield (file_id, (path_in_source, path_in_target), changed_content,
-                   versioned, parent, name, kind, executable)
+            yield (
+                file_id, (path_in_source, path_in_target), changed_content,
+                versioned, parent, name, kind, executable)
 
     def __len__(self):
         """Return the number of entries in the inventory."""
 
=== modified file 'breezy/bzr/inventorytree.py'
--- breezy/bzr/inventorytree.py	2019-06-15 01:02:49 +0000
+++ breezy/bzr/inventorytree.py	2019-06-15 17:35:57 +0000
@@ -893,16 +893,15 @@
         # FIXME: nested tree support
         for result in self.target.root_inventory.iter_changes(
                 self.source.root_inventory):
+            result = TreeChange(*result)
             if specific_file_ids is not None:
-                file_id = result[0]
-                if file_id not in specific_file_ids:
+                if result.file_id not in specific_file_ids:
                     # A change from the whole tree that we don't want to show yet.
                     # We may find that we need to show it for delta consistency, so
                     # stash it.
-                    discarded_changes[result[0]] = result
+                    discarded_changes[result.file_id] = result
                     continue
-                new_parent_id = result[4][1]
-                precise_file_ids.add(new_parent_id)
+                precise_file_ids.add(result.parent_id[1])
             yield result
             changed_file_ids.add(result[0])
         if specific_file_ids is not None:
 
=== modified file 'breezy/bzr/vf_repository.py'
--- breezy/bzr/vf_repository.py	2019-05-29 03:22:34 +0000
+++ breezy/bzr/vf_repository.py	2019-06-15 17:35:57 +0000
@@ -85,6 +85,7 @@
 from ..trace import (
     mutter
     )
+from ..tree import TreeChange
 
 
 class VersionedFileRepositoryFormat(RepositoryFormat):
@@ -374,12 +375,12 @@
         changes = {}
         for change in iter_changes:
             # This probably looks up in basis_inv way to much.
-            if change[1][0] is not None:
-                head_candidate = [basis_inv.get_entry(change[0]).revision]
+            if change.path[0] is not None:
+                head_candidate = [basis_inv.get_entry(change.file_id).revision]
             else:
                 head_candidate = []
-            changes[change[0]] = change, merged_ids.get(change[0],
-                                                        head_candidate)
+            changes[change.file_id] = change, merged_ids.get(
+                change.file_id, head_candidate)
         unchanged_merged = set(merged_ids) - set(changes)
         # Extend the changes dict with synthetic changes to record merges of
         # texts.
@@ -403,13 +404,14 @@
                 # by the user. So we discard this change.
                 pass
             else:
-                change = (file_id,
-                          (basis_inv.id2path(file_id), tree.id2path(file_id)),
-                          False, (True, True),
-                          (basis_entry.parent_id, basis_entry.parent_id),
-                          (basis_entry.name, basis_entry.name),
-                          (basis_entry.kind, basis_entry.kind),
-                          (basis_entry.executable, basis_entry.executable))
+                change = TreeChange(
+                    file_id,
+                    (basis_inv.id2path(file_id), tree.id2path(file_id)),
+                    False, (True, True),
+                    (basis_entry.parent_id, basis_entry.parent_id),
+                    (basis_entry.name, basis_entry.name),
+                    (basis_entry.kind, basis_entry.kind),
+                    (basis_entry.executable, basis_entry.executable))
                 changes[file_id] = (change, merged_ids[file_id])
         # changes contains tuples with the change and a set of inventory
         # candidates for the file.
@@ -419,7 +421,7 @@
         inv_delta = self._basis_delta
         modified_rev = self._new_revision_id
         for change, head_candidates in viewvalues(changes):
-            if change[3][1]:  # versioned in target.
+            if change.versioned[1]:  # versioned in target.
                 # Several things may be happening here:
                 # We may have a fork in the per-file graph
                 #  - record a change with the content from tree
@@ -427,11 +429,11 @@
                 #  - carry over the tree that hasn't changed
                 # We may have a change against all trees
                 #  - record the change with the content from tree
-                kind = change[6][1]
-                file_id = change[0]
-                entry = _entry_factory[kind](file_id, change[5][1],
-                                             change[4][1])
-                head_set = self._heads(change[0], set(head_candidates))
+                kind = change.kind[1]
+                file_id = change.file_id
+                entry = _entry_factory[kind](file_id, change.name[1],
+                                             change.parent_id[1])
+                head_set = self._heads(change.file_id, set(head_candidates))
                 heads = []
                 # Preserve ordering.
                 for head_candidate in head_candidates:
@@ -478,7 +480,7 @@
                     # other process reverts it while commit is running (with
                     # the revert happening after iter_changes did its
                     # examination).
-                    if change[7][1]:
+                    if change.executable[1]:
                         entry.executable = True
                     else:
                         entry.executable = False
@@ -489,11 +491,11 @@
                         nostore_sha = parent_entry.text_sha1
                     else:
                         nostore_sha = None
-                    file_obj, stat_value = tree.get_file_with_stat(change[1][1])
+                    file_obj, stat_value = tree.get_file_with_stat(change.path[1])
                     try:
                         entry.text_sha1, entry.text_size = self._add_file_to_weave(
                             file_id, file_obj, heads, nostore_sha)
-                        yield change[1][1], (entry.text_sha1, stat_value)
+                        yield change.path[1], (entry.text_sha1, stat_value)
                     except errors.ExistingContent:
                         # No content change against a carry_over parent
                         # Perhaps this should also yield a fs hash update?
@@ -505,23 +507,23 @@
                 elif kind == 'symlink':
                     # Wants a path hint?
                     entry.symlink_target = tree.get_symlink_target(
-                        change[1][1])
+                        change.path[1])
                     if (carry_over_possible and
                             parent_entry.symlink_target ==
                             entry.symlink_target):
                         carried_over = True
                     else:
                         self._add_file_to_weave(
-                            change[0], BytesIO(), heads, None)
+                            change.file_id, BytesIO(), heads, None)
                 elif kind == 'directory':
                     if carry_over_possible:
                         carried_over = True
                     else:
                         # Nothing to set on the entry.
                         # XXX: split into the Root and nonRoot versions.
-                        if change[1][1] != '' or self.repository.supports_rich_root():
+                        if change.path[1] != '' or self.repository.supports_rich_root():
                             self._add_file_to_weave(
-                                change[0], BytesIO(), heads, None)
+                                change.file_id, BytesIO(), heads, None)
                 elif kind == 'tree-reference':
                     if not self.repository._format.supports_tree_reference:
                         # This isn't quite sane as an error, but we shouldn't
@@ -531,7 +533,7 @@
                         raise errors.UnsupportedOperation(
                             tree.add_reference, self.repository)
                     reference_revision = tree.get_reference_revision(
-                        change[1][1])
+                        change.path[1])
                     entry.reference_revision = reference_revision
                     if (carry_over_possible
                             and parent_entry.reference_revision ==
@@ -539,7 +541,7 @@
                         carried_over = True
                     else:
                         self._add_file_to_weave(
-                            change[0], BytesIO(), heads, None)
+                            change.file_id, BytesIO(), heads, None)
                 else:
                     raise AssertionError('unknown kind %r' % kind)
                 if not carried_over:
@@ -548,8 +550,8 @@
                     entry.revision = parent_entry.revision
             else:
                 entry = None
-            new_path = change[1][1]
-            inv_delta.append((change[1][0], new_path, change[0], entry))
+            new_path = change.path[1]
+            inv_delta.append((change.path[0], new_path, change.file_id, entry))
             if new_path == '':
                 seen_root = True
         # The initial commit adds a root directory, but this in itself is not
 
=== modified file 'breezy/bzr/workingtree.py'
--- breezy/bzr/workingtree.py	2019-06-04 00:08:59 +0000
+++ breezy/bzr/workingtree.py	2019-06-15 17:35:57 +0000
@@ -426,19 +426,18 @@
 
             # Bail out if we are going to delete files we shouldn't
             if not keep_files and not force:
-                for (file_id, path, content_change, versioned, parent_id, name,
-                     kind, executable) in self.iter_changes(
-                         self.basis_tree(), include_unchanged=True,
-                         require_versioned=False, want_unversioned=True,
-                         specific_files=files):
-                    if versioned[0] is False:
+                for change in self.iter_changes(
+                        self.basis_tree(), include_unchanged=True,
+                        require_versioned=False, want_unversioned=True,
+                        specific_files=files):
+                    if change.versioned[0] is False:
                         # The record is unknown or newly added
-                        files_to_backup.append(path[1])
-                    elif (content_change and (kind[1] is not None)
-                            and osutils.is_inside_any(files, path[1])):
+                        files_to_backup.append(change.path[1])
+                    elif (change.changed_content and (change.kind[1] is not None)
+                            and osutils.is_inside_any(files, change.path[1])):
                         # Versioned and changed, but not deleted, and still
                         # in one of the dirs to be deleted.
-                        files_to_backup.append(path[1])
+                        files_to_backup.append(change.path[1])
 
             def backup(file_to_backup):
                 backup_name = self.controldir._available_backup_name(
 
=== modified file 'breezy/commit.py'
--- breezy/commit.py	2019-03-04 01:44:35 +0000
+++ breezy/commit.py	2019-06-15 17:35:57 +0000
@@ -69,6 +69,7 @@
                       minimum_path_selection,
                       )
 from .trace import mutter, note, is_quiet
+from .tree import TreeChange
 from .urlutils import unescape_for_display
 from .i18n import gettext
 
@@ -96,14 +97,11 @@
     :return: iter_changes function
     """
     for change in iter_changes:
-        old_path = change[1][0]
-        new_path = change[1][1]
-
-        new_excluded = (new_path is not None and
-                        is_inside_any(exclude, new_path))
-
-        old_excluded = (old_path is not None and
-                        is_inside_any(exclude, old_path))
+        new_excluded = (change.path[1] is not None and
+                        is_inside_any(exclude, change.path[1]))
+
+        old_excluded = (change.path[0] is not None and
+                        is_inside_any(exclude, change.path[0]))
 
         if old_excluded and new_excluded:
             continue
@@ -701,29 +699,28 @@
         deleted_paths = []
         for change in iter_changes:
             if report_changes:
-                old_path = change[1][0]
-                new_path = change[1][1]
-                versioned = change[3][1]
-            kind = change[6][1]
-            versioned = change[3][1]
+                old_path = change.path[0]
+                new_path = change.path[1]
+                versioned = change.versioned[1]
+            kind = change.kind[1]
+            versioned = change.versioned[1]
             if kind is None and versioned:
                 # 'missing' path
                 if report_changes:
                     reporter.missing(new_path)
-                if change[6][0] == 'symlink' and not self.work_tree.supports_symlinks():
+                if change.kind[0] == 'symlink' and not self.work_tree.supports_symlinks():
                     trace.warning('Ignoring "%s" as symlinks are not '
-                                  'supported on this filesystem.' % (change[1][0],))
+                                  'supported on this filesystem.' % (change.path[0],))
                     continue
                 deleted_paths.append(change[1][1])
                 # Reset the new path (None) and new versioned flag (False)
-                change = (change[0], (change[1][0], None), change[2],
-                          (change[3][0], False)) + change[4:]
-                new_path = change[1][1]
+                change = change.discard_new()
+                new_path = change.path[1]
                 versioned = False
             elif kind == 'tree-reference':
                 if self.recursive == 'down':
                     self._commit_nested_tree(change[1][1])
-            if change[3][0] or change[3][1]:
+            if change.versioned[0] or change.versioned[1]:
                 yield change
                 if report_changes:
                     if new_path is None:
 
=== modified file 'breezy/delta.py'
--- breezy/delta.py	2019-06-03 21:25:01 +0000
+++ breezy/delta.py	2019-06-15 17:35:57 +0000
@@ -125,48 +125,48 @@
     delta = TreeDelta()
     # mutter('start compare_trees')
 
-    for (file_id, path, content_change, versioned, parent_id, name, kind,
-         executable) in new_tree.iter_changes(old_tree, want_unchanged,
-                                              specific_files, extra_trees=extra_trees,
-                                              require_versioned=require_versioned,
-                                              want_unversioned=want_unversioned):
-        if versioned == (False, False):
-            delta.unversioned.append((path[1], None, kind[1]))
-            continue
-        if not include_root and (None, None) == parent_id:
-            continue
-        fully_present = tuple((versioned[x] and kind[x] is not None) for
-                              x in range(2))
+    for change in new_tree.iter_changes(
+            old_tree, want_unchanged, specific_files, extra_trees=extra_trees,
+            require_versioned=require_versioned,
+            want_unversioned=want_unversioned):
+        if change.versioned == (False, False):
+            delta.unversioned.append((change.path[1], None, change.kind[1]))
+            continue
+        if not include_root and (None, None) == change.parent_id:
+            continue
+        fully_present = tuple(
+            (change.versioned[x] and change.kind[x] is not None)
+            for x in range(2))
         if fully_present[0] != fully_present[1]:
             if fully_present[1] is True:
-                delta.added.append((path[1], file_id, kind[1]))
+                delta.added.append((change.path[1], change.file_id, change.kind[1]))
             else:
-                if kind[0] == 'symlink' and not new_tree.supports_symlinks():
+                if change.kind[0] == 'symlink' and not new_tree.supports_symlinks():
                     trace.warning(
                         'Ignoring "%s" as symlinks '
-                        'are not supported on this filesystem.' % (path[0],))
+                        'are not supported on this filesystem.' % (change.path[0],))
                 else:
-                    delta.removed.append((path[0], file_id, kind[0]))
+                    delta.removed.append(
+                        (change.path[0], change.file_id, change.kind[0]))
         elif fully_present[0] is False:
-            delta.missing.append((path[1], file_id, kind[1]))
-        elif name[0] != name[1] or parent_id[0] != parent_id[1]:
+            delta.missing.append((change.path[1], change.file_id, change.kind[1]))
+        elif change.name[0] != change.name[1] or change.parent_id[0] != change.parent_id[1]:
             # If the name changes, or the parent_id changes, we have a rename
             # (if we move a parent, that doesn't count as a rename for the
             # file)
-            delta.renamed.append((path[0],
-                                  path[1],
-                                  file_id,
-                                  kind[1],
-                                  content_change,
-                                  (executable[0] != executable[1])))
-        elif kind[0] != kind[1]:
-            delta.kind_changed.append((path[1], file_id, kind[0], kind[1]))
-        elif content_change or executable[0] != executable[1]:
-            delta.modified.append((path[1], file_id, kind[1],
-                                   content_change,
-                                   (executable[0] != executable[1])))
+            delta.renamed.append(
+                (change.path[0], change.path[1], change.file_id,
+                    change.kind[1], change.changed_content,
+                    (change.executable[0] != change.executable[1])))
+        elif change.kind[0] != change.kind[1]:
+            delta.kind_changed.append(
+                (change.path[1], change.file_id, change.kind[0], change.kind[1]))
+        elif change.changed_content or change.executable[0] != change.executable[1]:
+            delta.modified.append((change.path[1], change.file_id, change.kind[1],
+                                   change.changed_content,
+                                   (change.executable[0] != change.executable[1])))
         else:
-            delta.unchanged.append((path[1], file_id, kind[1]))
+            delta.unchanged.append((change.path[1], change.file_id, change.kind[1]))
 
     delta.removed.sort()
     delta.added.sort()
 
=== modified file 'breezy/diff.py'
--- breezy/diff.py	2019-06-15 14:43:05 +0000
+++ breezy/diff.py	2019-06-15 17:35:57 +0000
@@ -1060,23 +1060,24 @@
         def get_encoded_path(path):
             if path is not None:
                 return path.encode(self.path_encoding, "replace")
-        for (file_id, paths, changed_content, versioned, parent, name, kind,
-             executable) in sorted(iterator, key=changes_key):
+        for change in sorted(iterator, key=changes_key):
             # The root does not get diffed, and items with no known kind (that
             # is, missing) in both trees are skipped as well.
-            if parent == (None, None) or kind == (None, None):
+            if change.parent_id == (None, None) or change.kind == (None, None):
                 continue
-            if kind[0] == 'symlink' and not self.new_tree.supports_symlinks():
+            if change.kind[0] == 'symlink' and not self.new_tree.supports_symlinks():
                 warning(
                     'Ignoring "%s" as symlinks are not '
-                    'supported on this filesystem.' % (paths[0],))
+                    'supported on this filesystem.' % (change.path[0],))
                 continue
-            oldpath, newpath = paths
-            oldpath_encoded = get_encoded_path(paths[0])
-            newpath_encoded = get_encoded_path(paths[1])
-            old_present = (kind[0] is not None and versioned[0])
-            new_present = (kind[1] is not None and versioned[1])
-            renamed = (parent[0], name[0]) != (parent[1], name[1])
+            oldpath, newpath = change.path
+            oldpath_encoded = get_encoded_path(change.path[0])
+            newpath_encoded = get_encoded_path(change.path[1])
+            old_present = (change.kind[0] is not None and change.versioned[0])
+            new_present = (change.kind[1] is not None and change.versioned[1])
+            executable = change.executable
+            kind = change.kind
+            renamed = (change.parent_id[0], change.name[0]) != (change.parent_id[1], change.name[1])
 
             properties_changed = []
             properties_changed.extend(
@@ -1104,7 +1105,7 @@
                 # modified *somehow*, either content or execute bit.
                 self.to_file.write(b"=== modified %s '%s'%s\n" % (kind[0].encode('ascii'),
                                                                   newpath_encoded, prop_str))
-            if changed_content:
+            if change.changed_content:
                 self._diff(oldpath, newpath, kind[0], kind[1])
                 has_changes = 1
             if renamed:
 
=== modified file 'breezy/git/commit.py'
--- breezy/git/commit.py	2019-06-15 13:38:17 +0000
+++ breezy/git/commit.py	2019-06-15 17:35:57 +0000
@@ -88,32 +88,32 @@
 
     def record_iter_changes(self, workingtree, basis_revid, iter_changes):
         seen_root = False
-        for (file_id, path, changed_content, versioned, parent, name, kind,
-             executable) in iter_changes:
-            if kind[1] in ("directory",):
+        for change in iter_changes:
+            if change.kind[1] in ("directory",):
                 self._inv_delta.append(
-                    (path[0], path[1], file_id, entry_factory[kind[1]](
-                        file_id, name[1], parent[1])))
-                if kind[0] in ("file", "symlink"):
-                    self._blobs[path[0].encode("utf-8")] = None
+                    (change.path[0], change.path[1], change.file_id,
+                     entry_factory[change.kind[1]](
+                         change.file_id, change.name[1], change.parent_id[1])))
+                if change.kind[0] in ("file", "symlink"):
+                    self._blobs[change.path[0].encode("utf-8")] = None
                     self._any_changes = True
-                if path[1] == "":
+                if change.path[1] == "":
                     seen_root = True
                 continue
             self._any_changes = True
-            if path[1] is None:
-                self._inv_delta.append((path[0], path[1], file_id, None))
-                self._blobs[path[0].encode("utf-8")] = None
+            if change.path[1] is None:
+                self._inv_delta.append((change.path[0], change.path[1], change.file_id, None))
+                self._blobs[change.path[0].encode("utf-8")] = None
                 continue
             try:
-                entry_kls = entry_factory[kind[1]]
+                entry_kls = entry_factory[change.kind[1]]
             except KeyError:
-                raise KeyError("unknown kind %s" % kind[1])
-            entry = entry_kls(file_id, name[1], parent[1])
-            if kind[1] == "file":
-                entry.executable = executable[1]
+                raise KeyError("unknown kind %s" % change.kind[1])
+            entry = entry_kls(change.file_id, change.name[1], change.parent_id[1])
+            if change.kind[1] == "file":
+                entry.executable = change.executable[1]
                 blob = Blob()
-                f, st = workingtree.get_file_with_stat(path[1])
+                f, st = workingtree.get_file_with_stat(change.path[1])
                 try:
                     blob.data = f.read()
                 finally:
@@ -122,29 +122,29 @@
                 entry.text_sha1 = osutils.sha_string(blob.data)
                 self.store.add_object(blob)
                 sha = blob.id
-            elif kind[1] == "symlink":
-                symlink_target = workingtree.get_symlink_target(path[1])
+            elif change.kind[1] == "symlink":
+                symlink_target = workingtree.get_symlink_target(change.path[1])
                 blob = Blob()
                 blob.data = symlink_target.encode("utf-8")
                 self.store.add_object(blob)
                 sha = blob.id
                 entry.symlink_target = symlink_target
                 st = None
-            elif kind[1] == "tree-reference":
-                sha = read_submodule_head(workingtree.abspath(path[1]))
-                reference_revision = workingtree.get_reference_revision(path[1])
+            elif change.kind[1] == "tree-reference":
+                sha = read_submodule_head(workingtree.abspath(change.path[1]))
+                reference_revision = workingtree.get_reference_revision(change.path[1])
                 entry.reference_revision = reference_revision
                 st = None
             else:
-                raise AssertionError("Unknown kind %r" % kind[1])
-            mode = object_mode(kind[1], executable[1])
-            self._inv_delta.append((path[0], path[1], file_id, entry))
-            encoded_new_path = path[1].encode("utf-8")
+                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))
+            encoded_new_path = change.path[1].encode("utf-8")
             self._blobs[encoded_new_path] = (mode, sha)
             if st is not None:
-                yield path[1], (entry.text_sha1, st)
-            if self._mapping.generate_file_id(encoded_new_path) != file_id:
-                self._override_fileids[encoded_new_path] = file_id
+                yield change.path[1], (entry.text_sha1, st)
+            if self._mapping.generate_file_id(encoded_new_path) != change.file_id:
+                self._override_fileids[encoded_new_path] = change.file_id
             else:
                 self._override_fileids[encoded_new_path] = None
         if not seen_root and len(self.parents) == 0:
 
=== modified file 'breezy/git/object_store.py'
--- breezy/git/object_store.py	2019-06-06 22:22:47 +0000
+++ breezy/git/object_store.py	2019-06-15 17:35:57 +0000
@@ -249,16 +249,15 @@
         raise KeyError
 
     # Find all the changed blobs
-    for (file_id, path, changed_content, versioned, parent, name, kind,
-         executable) in tree.iter_changes(base_tree):
-        if name[1] in BANNED_FILENAMES:
+    for change in tree.iter_changes(base_tree):
+        if change.name[1] in BANNED_FILENAMES:
             continue
-        if kind[1] == "file":
-            sha1 = tree.get_file_sha1(path[1])
+        if change.kind[1] == "file":
+            sha1 = tree.get_file_sha1(change.path[1])
             blob_id = None
             try:
                 (pfile_id, prevision) = find_unchanged_parent_ie(
-                    file_id, kind[1], sha1, other_parent_trees)
+                    change.file_id, change.kind[1], sha1, other_parent_trees)
             except KeyError:
                 pass
             else:
@@ -271,35 +270,35 @@
                     if not changed_content:
                         # no-change merge ?
                         blob = Blob()
-                        blob.data = tree.get_file_text(path[1])
+                        blob.data = tree.get_file_text(change.path[1])
                         blob_id = blob.id
             if blob_id is None:
-                new_blobs.append((path[1], file_id))
+                new_blobs.append((change.path[1], change.file_id))
             else:
                 shamap[path[1]] = blob_id
                 if add_cache_entry is not None:
                     add_cache_entry(
                         ("blob", blob_id),
-                        (file_id, tree.get_file_revision(path[1])), path[1])
-        elif kind[1] == "symlink":
-            target = tree.get_symlink_target(path[1])
+                        (file_id, tree.get_file_revision(change.path[1])), change.path[1])
+        elif change.kind[1] == "symlink":
+            target = tree.get_symlink_target(change.path[1])
             blob = symlink_to_blob(target)
-            shamap[path[1]] = blob.id
+            shamap[change.path[1]] = blob.id
             if add_cache_entry is not None:
                 add_cache_entry(
-                    blob, (file_id, tree.get_file_revision(path[1])), path[1])
+                    blob, (change.file_id, tree.get_file_revision(change.path[1])), change.path[1])
             try:
                 find_unchanged_parent_ie(
-                    file_id, kind[1], target, other_parent_trees)
+                    change.file_id, change.kind[1], target, other_parent_trees)
             except KeyError:
-                if changed_content:
-                    yield (path[1], blob,
-                           (file_id, tree.get_file_revision(path[1])))
-        elif kind[1] is None:
-            shamap[path[1]] = None
-        elif kind[1] != 'directory':
-            raise AssertionError(kind[1])
-        for p in path:
+                if change.changed_content:
+                    yield (change.path[1], blob,
+                           (change.file_id, tree.get_file_revision(change.path[1])))
+        elif change.kind[1] is None:
+            shamap[change.path[1]] = None
+        elif change.kind[1] != 'directory':
+            raise AssertionError(change.kind[1])
+        for p in change.path:
             if p is None:
                 continue
             dirty_dirs.add(osutils.dirname(p))
 
=== modified file 'breezy/git/workingtree.py'
--- breezy/git/workingtree.py	2019-06-04 00:08:59 +0000
+++ breezy/git/workingtree.py	2019-06-15 17:35:57 +0000
@@ -350,23 +350,22 @@
 
             # Bail out if we are going to delete files we shouldn't
             if not keep_files and not force:
-                for (file_id, path, content_change, versioned, parent_id, name,
-                     kind, executable) in self.iter_changes(
-                         self.basis_tree(), include_unchanged=True,
-                         require_versioned=False, want_unversioned=True,
-                         specific_files=files):
-                    if versioned[0] is False:
+                for change in self.iter_changes(
+                        self.basis_tree(), include_unchanged=True,
+                        require_versioned=False, want_unversioned=True,
+                        specific_files=files):
+                    if change.versioned[0] is False:
                         # The record is unknown or newly added
-                        files_to_backup.append(path[1])
+                        files_to_backup.append(change.path[1])
                         files_to_backup.extend(
-                            osutils.parent_directories(path[1]))
-                    elif (content_change and (kind[1] is not None)
-                            and osutils.is_inside_any(files, path[1])):
+                            osutils.parent_directories(change.path[1]))
+                    elif (change.changed_content and (change.kind[1] is not None)
+                            and osutils.is_inside_any(files, change.path[1])):
                         # Versioned and changed, but not deleted, and still
                         # in one of the dirs to be deleted.
-                        files_to_backup.append(path[1])
+                        files_to_backup.append(change.path[1])
                         files_to_backup.extend(
-                            osutils.parent_directories(path[1]))
+                            osutils.parent_directories(change.path[1]))
 
             for f in files:
                 if f == '':
 
=== modified file 'breezy/merge.py'
--- breezy/merge.py	2019-06-03 05:21:20 +0000
+++ breezy/merge.py	2019-06-15 17:35:57 +0000
@@ -852,14 +852,13 @@
             self.interesting_files, trees=[self.other_tree])
         this_entries = dict(self.this_tree.iter_entries_by_dir(
                             specific_files=this_interesting_files))
-        for (file_id, paths, changed, versioned, parents, names, kind,
-             executable) in iterator:
-            if paths[0] is not None:
+        for change in iterator:
+            if change.path[0] is not None:
                 this_path = _mod_tree.find_previous_path(
-                    self.base_tree, self.this_tree, paths[0])
+                    self.base_tree, self.this_tree, change.path[0])
             else:
                 this_path = _mod_tree.find_previous_path(
-                    self.other_tree, self.this_tree, paths[1])
+                    self.other_tree, self.this_tree, change.path[1])
             this_entry = this_entries.get(this_path)
             if this_entry is not None:
                 this_name = this_entry.name
@@ -869,12 +868,13 @@
                 this_name = None
                 this_parent = None
                 this_executable = None
-            parents3 = parents + (this_parent,)
-            names3 = names + (this_name,)
-            paths3 = paths + (this_path, )
-            executable3 = executable + (this_executable,)
-            result.append((file_id, changed, paths3,
-                           parents3, names3, executable3))
+            parents3 = change.parent_id + (this_parent,)
+            names3 = change.name + (this_name,)
+            paths3 = change.path + (this_path, )
+            executable3 = change.executable + (this_executable,)
+            result.append(
+                (change.file_id, change.changed_content, paths3,
+                 parents3, names3, executable3))
         return result
 
     def _entries_lca(self):
 
=== modified file 'breezy/mutabletree.py'
--- breezy/mutabletree.py	2019-06-03 23:45:30 +0000
+++ breezy/mutabletree.py	2019-06-15 17:35:57 +0000
@@ -202,7 +202,7 @@
                 try:
                     change = next(changes)
                     # Exclude root (talk about black magic... --vila 20090629)
-                    if change[4] == (None, None):
+                    if change.parent_id == (None, None):
                         change = next(changes)
                     return True
                 except StopIteration:
 
=== modified file 'breezy/plugins/fastimport/revision_store.py'
--- breezy/plugins/fastimport/revision_store.py	2018-11-25 20:44:56 +0000
+++ breezy/plugins/fastimport/revision_store.py	2019-06-15 17:35:57 +0000
@@ -25,6 +25,7 @@
     osutils,
     revision as _mod_revision,
     )
+from ...tree import TreeChange
 from ...bzr import (
     inventory,
     )
@@ -118,49 +119,53 @@
                 old_ie = None
                 if ie is None:
                     raise AssertionError('How is both old and new None?')
-                    change = (file_id,
-                              (old_path, new_path),
-                              False,
-                              (False, False),
-                              (None, None),
-                              (None, None),
-                              (None, None),
-                              (None, None),
-                              )
-                change = (file_id,
-                          (old_path, new_path),
-                          True,
-                          (False, True),
-                          (None, ie.parent_id),
-                          (None, ie.name),
-                          (None, ie.kind),
-                          (None, ie.executable),
-                          )
+                    change = TreeChange(
+                        file_id,
+                        (old_path, new_path),
+                        False,
+                        (False, False),
+                        (None, None),
+                        (None, None),
+                        (None, None),
+                        (None, None),
+                        )
+                change = TreeChange(
+                    file_id,
+                    (old_path, new_path),
+                    True,
+                    (False, True),
+                    (None, ie.parent_id),
+                    (None, ie.name),
+                    (None, ie.kind),
+                    (None, ie.executable),
+                    )
             else:
                 if ie is None:
-                    change = (file_id,
-                              (old_path, new_path),
-                              True,
-                              (True, False),
-                              (old_ie.parent_id, None),
-                              (old_ie.name, None),
-                              (old_ie.kind, None),
-                              (old_ie.executable, None),
-                              )
+                    change = TreeChange(
+                        file_id,
+                        (old_path, new_path),
+                        True,
+                        (True, False),
+                        (old_ie.parent_id, None),
+                        (old_ie.name, None),
+                        (old_ie.kind, None),
+                        (old_ie.executable, None),
+                        )
                 else:
                     content_modified = (ie.text_sha1 != old_ie.text_sha1 or
                                         ie.text_size != old_ie.text_size)
                     # TODO: ie.kind != old_ie.kind
                     # TODO: symlinks changing targets, content_modified?
-                    change = (file_id,
-                              (old_path, new_path),
-                              content_modified,
-                              (True, True),
-                              (old_ie.parent_id, ie.parent_id),
-                              (old_ie.name, ie.name),
-                              (old_ie.kind, ie.kind),
-                              (old_ie.executable, ie.executable),
-                              )
+                    change = TreeChange(
+                        file_id,
+                        (old_path, new_path),
+                        content_modified,
+                        (True, True),
+                        (old_ie.parent_id, ie.parent_id),
+                        (old_ie.name, ie.name),
+                        (old_ie.kind, ie.kind),
+                        (old_ie.executable, ie.executable),
+                        )
             yield change
 
 
 
=== modified file 'breezy/plugins/launchpad/lp_propose.py'
--- breezy/plugins/launchpad/lp_propose.py	2019-01-28 21:00:58 +0000
+++ breezy/plugins/launchpad/lp_propose.py	2019-06-15 17:35:57 +0000
@@ -224,7 +224,6 @@
 
 def modified_files(old_tree, new_tree):
     """Return a list of paths in the new tree with modified contents."""
-    for f, (op, path), c, v, p, n, (ok, k), e in new_tree.iter_changes(
-            old_tree):
-        if c and k == 'file':
+    for change in new_tree.iter_changes(old_tree):
+        if change.changed_content and change.kind[1] == 'file':
             yield str(path)
 
=== modified file 'breezy/plugins/propose/launchpad.py'
--- breezy/plugins/propose/launchpad.py	2019-06-15 14:25:08 +0000
+++ breezy/plugins/propose/launchpad.py	2019-06-15 17:35:57 +0000
@@ -687,7 +687,6 @@
 
 def modified_files(old_tree, new_tree):
     """Return a list of paths in the new tree with modified contents."""
-    for f, (op, path), c, v, p, n, (ok, k), e in new_tree.iter_changes(
-            old_tree):
-        if c and k == 'file':
+    for change in new_tree.iter_changes(old_tree):
+        if change.changed_content and change.kind[1] == 'file':
             yield str(path)
 
=== modified file 'breezy/rename_map.py'
--- breezy/rename_map.py	2018-11-11 04:08:32 +0000
+++ breezy/rename_map.py	2019-06-15 17:35:57 +0000
@@ -177,24 +177,24 @@
         with ui_factory.nested_progress_bar() as task:
             iterator = self.tree.iter_changes(basis, want_unversioned=True,
                                               pb=task)
-            for (file_id, paths, changed_content, versioned, parent, name,
-                 kind, executable) in iterator:
-                if kind[1] is None and versioned[1]:
-                    if not self.tree.has_filename(self.tree.id2path(parent[0])):
+            for change in iterator:
+                if change.kind[1] is None and change.versioned[1]:
+                    if not self.tree.has_filename(
+                            self.tree.id2path(change.parent_id[0])):
                         missing_parents.setdefault(
-                            parent[0], set()).add(file_id)
-                    if kind[0] == 'file':
-                        missing_files.add(file_id)
+                            change.parent_id[0], set()).add(change.file_id)
+                    if change.kind[0] == 'file':
+                        missing_files.add(change.file_id)
                     else:
                         # other kinds are not handled
                         pass
-                if versioned == (False, False):
-                    if self.tree.is_ignored(paths[1]):
+                if change.versioned == (False, False):
+                    if self.tree.is_ignored(change.path[1]):
                         continue
-                    if kind[1] == 'file':
-                        candidate_files.add(paths[1])
-                    if kind[1] == 'directory':
-                        for _dir, children in self.tree.walkdirs(paths[1]):
+                    if change.kind[1] == 'file':
+                        candidate_files.add(change.path[1])
+                    if change.kind[1] == 'directory':
+                        for _dir, children in self.tree.walkdirs(change.path[1]):
                             for child in children:
                                 if child[2] == 'file':
                                     candidate_files.add(child[0])
 
=== modified file 'breezy/shelf.py'
--- breezy/shelf.py	2018-11-17 16:53:10 +0000
+++ breezy/shelf.py	2019-06-15 17:35:57 +0000
@@ -98,39 +98,38 @@
            ('modify text', file_id)
            ('modify target', file_id, target_target, work_target)
         """
-        for (file_id, paths, changed, versioned, parents, names, kind,
-             executable) in self.iter_changes:
+        for change in self.iter_changes:
             # don't shelve add of tree root.  Working tree should never
             # lack roots, and bzr misbehaves when they do.
             # FIXME ADHB (2009-08-09): should still shelve adds of tree roots
             # when a tree root was deleted / renamed.
-            if kind[0] is None and names[1] == '':
+            if change.kind[0] is None and change.name[1] == '':
                 continue
             # Also don't shelve deletion of tree root.
-            if kind[1] is None and names[0] == '':
+            if change.kind[1] is None and change.name[0] == '':
                 continue
-            if kind[0] is None or versioned[0] is False:
-                self.creation[file_id] = (kind[1], names[1], parents[1],
-                                          versioned)
-                yield ('add file', file_id, kind[1], paths[1])
-            elif kind[1] is None or versioned[0] is False:
-                self.deletion[file_id] = (kind[0], names[0], parents[0],
-                                          versioned)
-                yield ('delete file', file_id, kind[0], paths[0])
+            if change.kind[0] is None or change.versioned[0] is False:
+                self.creation[change.file_id] = (
+                    change.kind[1], change.name[1], change.parent_id[1], change.versioned)
+                yield ('add file', change.file_id, change.kind[1], change.path[1])
+            elif change.kind[1] is None or change.versioned[0] is False:
+                self.deletion[change.file_id] = (
+                    change.kind[0], change.name[0], change.parent_id[0], change.versioned)
+                yield ('delete file', change.file_id, change.kind[0], change.path[0])
             else:
-                if names[0] != names[1] or parents[0] != parents[1]:
-                    self.renames[file_id] = (names, parents)
-                    yield ('rename', file_id) + paths
+                if change.name[0] != change.name[1] or change.parent_id[0] != change.parent_id[1]:
+                    self.renames[change.file_id] = (change.name, change.parent_id)
+                    yield ('rename', change.file_id) + change.path
 
-                if kind[0] != kind[1]:
-                    yield ('change kind', file_id, kind[0], kind[1], paths[0])
-                elif kind[0] == 'symlink':
-                    t_target = self.target_tree.get_symlink_target(paths[0])
-                    w_target = self.work_tree.get_symlink_target(paths[1])
-                    yield ('modify target', file_id, paths[0], t_target,
+                if change.kind[0] != change.kind[1]:
+                    yield ('change kind', change.file_id, change.kind[0], change.kind[1], change.path[0])
+                elif change.kind[0] == 'symlink':
+                    t_target = self.target_tree.get_symlink_target(change.path[0])
+                    w_target = self.work_tree.get_symlink_target(change.path[1])
+                    yield ('modify target', change.file_id, change.path[0], t_target,
                            w_target)
-                elif changed:
-                    yield ('modify text', file_id)
+                elif change.changed_content:
+                    yield ('modify text', change.file_id)
 
     def shelve_change(self, change):
         """Shelve a change in the iter_shelvable format."""
 
=== modified file 'breezy/tests/per_intertree/test_compare.py'
--- breezy/tests/per_intertree/test_compare.py	2018-12-18 20:55:37 +0000
+++ breezy/tests/per_intertree/test_compare.py	2019-06-15 17:35:57 +0000
@@ -26,6 +26,7 @@
     transform,
     )
 from breezy.osutils import has_symlinks
+from breezy.tree import TreeChange
 from breezy.tests.per_intertree import TestCaseWithTwoTrees
 from breezy.tests import (
     features,
@@ -50,10 +51,9 @@
 
 def _change_key(change):
     """Return a valid key for sorting Tree.iter_changes entries."""
-    (file_id, paths, content_changed, versioned, parent, name, kind,
-     executable) = change
-    return (file_id or b'', (paths[0] or '', paths[1] or ''), versioned,
-            parent, name, kind, executable)
+    return (change.file_id or b'', (change.path[0] or '', change.path[1] or ''),
+            change.versioned, change.parent_id, change.name, change.kind,
+            change.executable)
 
 
 class TestCompare(TestCaseWithTwoTrees):
@@ -553,9 +553,10 @@
 
     def added(self, tree, file_id):
         path, entry = self.get_path_entry(tree, file_id)
-        return (file_id, (None, path), True, (False, True), (None, entry.parent_id),
-                (None, entry.name), (None, entry.kind),
-                (None, entry.executable))
+        return TreeChange(
+            file_id, (None, path), True, (False, True), (None, entry.parent_id),
+            (None, entry.name), (None, entry.kind),
+            (None, entry.executable))
 
     @staticmethod
     def get_path_entry(tree, file_id):
@@ -569,43 +570,48 @@
 
     def content_changed(self, tree, file_id):
         path, entry = self.get_path_entry(tree, file_id)
-        return (file_id, (path, path), True, (True, True),
-                (entry.parent_id, entry.parent_id),
-                (entry.name, entry.name), (entry.kind, entry.kind),
-                (entry.executable, entry.executable))
+        return TreeChange(
+            file_id, (path, path), True, (True, True),
+            (entry.parent_id, entry.parent_id),
+            (entry.name, entry.name), (entry.kind, entry.kind),
+            (entry.executable, entry.executable))
 
     def kind_changed(self, from_tree, to_tree, file_id):
         from_path, old_entry = self.get_path_entry(from_tree, file_id)
         path, new_entry = self.get_path_entry(to_tree, file_id)
-        return (file_id, (from_path, path), True, (True, True),
-                (old_entry.parent_id, new_entry.parent_id),
-                (old_entry.name, new_entry.name),
-                (old_entry.kind, new_entry.kind),
-                (old_entry.executable, new_entry.executable))
+        return TreeChange(
+            file_id, (from_path, path), True, (True, True),
+            (old_entry.parent_id, new_entry.parent_id),
+            (old_entry.name, new_entry.name),
+            (old_entry.kind, new_entry.kind),
+            (old_entry.executable, new_entry.executable))
 
     def missing(self, file_id, from_path, to_path, parent_id, kind):
         _, from_basename = os.path.split(from_path)
         _, to_basename = os.path.split(to_path)
         # missing files have both paths, but no kind.
-        return (file_id, (from_path, to_path), True, (True, True),
-                (parent_id, parent_id),
-                (from_basename, to_basename), (kind, None), (False, False))
+        return TreeChange(
+            file_id, (from_path, to_path), True, (True, True),
+            (parent_id, parent_id),
+            (from_basename, to_basename), (kind, None), (False, False))
 
     def deleted(self, tree, file_id):
         entry = tree.root_inventory.get_entry(file_id)
         path = tree.id2path(file_id)
-        return (file_id, (path, None), True, (True, False), (entry.parent_id, None),
-                (entry.name, None), (entry.kind, None),
-                (entry.executable, None))
+        return TreeChange(
+            file_id, (path, None), True, (True, False), (entry.parent_id, None),
+            (entry.name, None), (entry.kind, None),
+            (entry.executable, None))
 
     def renamed(self, from_tree, to_tree, file_id, content_changed):
         from_path, from_entry = self.get_path_entry(from_tree, file_id)
         to_path, to_entry = self.get_path_entry(to_tree, file_id)
-        return (file_id, (from_path, to_path), content_changed, (True, True),
-                (from_entry.parent_id, to_entry.parent_id),
-                (from_entry.name, to_entry.name),
-                (from_entry.kind, to_entry.kind),
-                (from_entry.executable, to_entry.executable))
+        return TreeChange(
+            file_id, (from_path, to_path), content_changed, (True, True),
+            (from_entry.parent_id, to_entry.parent_id),
+            (from_entry.name, to_entry.name),
+            (from_entry.kind, to_entry.kind),
+            (from_entry.executable, to_entry.executable))
 
     def unchanged(self, tree, file_id):
         path, entry = self.get_path_entry(tree, file_id)
@@ -613,17 +619,19 @@
         name = entry.name
         kind = entry.kind
         executable = entry.executable
-        return (file_id, (path, path), False, (True, True),
-                (parent, parent), (name, name), (kind, kind),
-                (executable, executable))
+        return TreeChange(
+            file_id, (path, path), False, (True, True),
+            (parent, parent), (name, name), (kind, kind),
+            (executable, executable))
 
     def unversioned(self, tree, path):
         """Create an unversioned result."""
         _, basename = os.path.split(path)
         kind = tree._comparison_data(None, path)[0]
-        return (None, (None, path), True, (False, False), (None, None),
-                (None, basename), (None, kind),
-                (None, False))
+        return TreeChange(
+            None, (None, path), True, (False, False), (None, None),
+            (None, basename), (None, kind),
+            (None, False))
 
     def sorted(self, changes):
         return sorted(changes, key=_change_key)
@@ -1086,8 +1094,9 @@
         tree1, tree2 = self.mutable_trees_to_locked_test_trees(tree1, tree2)
         self.not_applicable_if_missing_in('file', tree1)
         root_id = tree1.path2id('')
-        expected = [(b'file-id', ('file', None), False, (True, False),
-                     (root_id, None), ('file', None), (None, None), (False, None))]
+        expected = [
+            TreeChange(b'file-id', ('file', None), False, (True, False),
+                       (root_id, None), ('file', None), (None, None), (False, None))]
         self.assertEqual(expected, self.do_iter_changes(tree1, tree2))
 
     def test_only_in_target_and_missing(self):
@@ -1100,8 +1109,9 @@
         tree1, tree2 = self.mutable_trees_to_locked_test_trees(tree1, tree2)
         self.not_applicable_if_missing_in('file', tree2)
         root_id = tree1.path2id('')
-        expected = [(b'file-id', (None, 'file'), False, (False, True),
-                     (None, root_id), (None, 'file'), (None, None), (None, False))]
+        expected = [
+            TreeChange(b'file-id', (None, 'file'), False, (False, True),
+                       (None, root_id), (None, 'file'), (None, None), (None, False))]
         self.assertEqual(expected, self.do_iter_changes(tree1, tree2))
 
     def test_only_in_target_missing_subtree_specific_bug_367632(self):
@@ -1116,10 +1126,12 @@
         self.not_applicable_if_missing_in('a-dir', tree2)
         root_id = tree1.path2id('')
         expected = [
-            (b'dir-id', (None, 'a-dir'), False, (False, True),
-             (None, root_id), (None, 'a-dir'), (None, None), (None, False)),
-            (b'file-id', (None, 'a-dir/a-file'), False, (False, True),
-             (None, b'dir-id'), (None, 'a-file'), (None, None), (None, False))
+            TreeChange(
+                b'dir-id', (None, 'a-dir'), False, (False, True),
+                (None, root_id), (None, 'a-dir'), (None, None), (None, False)),
+            TreeChange(
+                b'file-id', (None, 'a-dir/a-file'), False, (False, True),
+                (None, b'dir-id'), (None, 'a-file'), (None, None), (None, False))
             ]
         # bug 367632 showed that specifying the root broke some code paths,
         # so we check this contract with and without it.
@@ -1136,10 +1148,11 @@
         tree1, tree2 = self.mutable_trees_to_locked_test_trees(tree1, tree2)
         self.assertEqual(sorted([self.unchanged(tree1, b'root-id'),
                                  self.unchanged(tree1, b'b-id'),
-                                 (b'a-id', ('a', 'd'), True, (True, True),
-                                  (b'root-id', b'root-id'), ('a',
-                                                             'd'), ('file', 'file'),
-                                  (False, False)), self.unchanged(tree1, b'c-id')]),
+                                 TreeChange(
+                                     b'a-id', ('a', 'd'), True, (True, True),
+                                     (b'root-id', b'root-id'), ('a', 'd'),
+                                     ('file', 'file'),
+                                     (False, False)), self.unchanged(tree1, b'c-id')]),
                          self.do_iter_changes(tree1, tree2, include_unchanged=True))
 
     def test_compare_subtrees(self):
@@ -1163,22 +1176,24 @@
         self.assertEqual([], list(tree2.iter_changes(tree1)))
         subtree1.commit('commit', rev_id=b'commit-a')
         self.assertEqual([
-            (b'root-id',
-             (u'', u''),
-             False,
-             (True, True),
-             (None, None),
-             (u'', u''),
-             ('directory', 'directory'),
-             (False, False)),
-            (b'subtree-id',
-             ('sub', 'sub',),
-             False,
-             (True, True),
-             (b'root-id', b'root-id'),
-             ('sub', 'sub'),
-             ('tree-reference', 'tree-reference'),
-             (False, False))],
+            TreeChange(
+                b'root-id',
+                (u'', u''),
+                False,
+                (True, True),
+                (None, None),
+                (u'', u''),
+                ('directory', 'directory'),
+                (False, False)),
+            TreeChange(
+                b'subtree-id',
+                ('sub', 'sub',),
+                False,
+                (True, True),
+                (b'root-id', b'root-id'),
+                ('sub', 'sub'),
+                ('tree-reference', 'tree-reference'),
+                (False, False))],
             list(tree2.iter_changes(tree1,
                                     include_unchanged=True)))
 
 
=== modified file 'breezy/tests/per_repository/test_check.py'
--- breezy/tests/per_repository/test_check.py	2018-11-11 04:08:32 +0000
+++ breezy/tests/per_repository/test_check.py	2019-06-15 17:35:57 +0000
@@ -20,6 +20,7 @@
 from breezy import (
     revision as _mod_revision,
     )
+from breezy.tree import TreeChange
 from breezy.tests.per_repository import TestCaseWithRepository
 
 
@@ -32,8 +33,9 @@
         self.overrideEnv('BRZ_EMAIL', '[e-mail]')
         builder = branch.get_commit_builder([], branch.get_config_stack())
         list(builder.record_iter_changes(None, _mod_revision.NULL_REVISION, [
-            (b'TREE_ROOT', (None, ''), True, (False, True), (None, None),
-             (None, ''), (None, 'directory'), (None, False))]))
+            TreeChange(
+                b'TREE_ROOT', (None, ''), True, (False, True), (None, None),
+                (None, ''), (None, 'directory'), (None, False))]))
         builder.finish_inventory()
         rev_id = builder.commit('first post')
         result = branch.repository.check(None, check_repo=True)
 
=== modified file 'breezy/tests/per_repository/test_commit_builder.py'
--- breezy/tests/per_repository/test_commit_builder.py	2018-11-25 20:44:56 +0000
+++ breezy/tests/per_repository/test_commit_builder.py	2019-06-15 17:35:57 +0000
@@ -26,6 +26,7 @@
     revision as _mod_revision,
     tests,
     )
+from breezy.tree import TreeChange
 from breezy.bzr import (
     inventorytree,
     )
@@ -193,10 +194,11 @@
         with tree.lock_write():
             builder = tree.branch.get_commit_builder([rev_id])
             try:
-                delete_change = (foo_id, ('foo', None), True, (True, False),
-                                 (tree.path2id(''), None), ('foo',
-                                                            None), ('file', None),
-                                 (False, None))
+                delete_change = TreeChange(
+                    foo_id, ('foo', None), True, (True, False),
+                    (tree.path2id(''), None),
+                    ('foo', None), ('file', None),
+                    (False, None))
                 list(builder.record_iter_changes(tree, rev_id,
                                                  [delete_change]))
                 self.assertEqual(("foo", None, foo_id, None),
 
=== modified file 'breezy/tests/test__dirstate_helpers.py'
--- breezy/tests/test__dirstate_helpers.py	2019-06-03 21:25:01 +0000
+++ breezy/tests/test__dirstate_helpers.py	2019-06-15 17:35:57 +0000
@@ -1260,7 +1260,7 @@
         state._sha1_provider = UppercaseSHA1Provider()
         # If we used the standard provider, it would look like nothing has
         # changed
-        file_ids_changed = [change[0] for change
+        file_ids_changed = [change.file_id for change
                             in tree.iter_changes(tree.basis_tree())]
         self.assertEqual([b'a-file-id'], file_ids_changed)
 
@@ -1291,12 +1291,9 @@
         self.overrideAttr(dirstate, '_process_entry', self._process_entry)
 
     def assertChangedFileIds(self, expected, tree):
-        tree.lock_read()
-        try:
-            file_ids = [info[0] for info
+        with tree.lock_read():
+            file_ids = [info.file_id for info
                         in tree.iter_changes(tree.basis_tree())]
-        finally:
-            tree.unlock()
         self.assertEqual(sorted(expected), sorted(file_ids))
 
     def test_exceptions_raised(self):
 
=== modified file 'breezy/tests/test_commit.py'
--- breezy/tests/test_commit.py	2019-06-03 23:24:45 +0000
+++ breezy/tests/test_commit.py	2019-06-15 17:35:57 +0000
@@ -38,6 +38,7 @@
     BzrError,
     LockContention,
     )
+from ..tree import TreeChange
 from . import (
     TestCase,
     TestCaseWithTransport,
@@ -894,30 +895,34 @@
 
     def test_add_file_not_excluded(self):
         changes = [
-            ('fid', (None, 'newpath'),
-             0, (False, False), ('pid', 'pid'), ('newpath', 'newpath'),
-             ('file', 'file'), (True, True))]
+            TreeChange(
+                'fid', (None, 'newpath'),
+                0, (False, False), ('pid', 'pid'), ('newpath', 'newpath'),
+                ('file', 'file'), (True, True))]
         self.assertEqual(changes, list(
             filter_excluded(changes, ['otherpath'])))
 
     def test_add_file_excluded(self):
         changes = [
-            ('fid', (None, 'newpath'),
-             0, (False, False), ('pid', 'pid'), ('newpath', 'newpath'),
-             ('file', 'file'), (True, True))]
+            TreeChange(
+                'fid', (None, 'newpath'),
+                0, (False, False), ('pid', 'pid'), ('newpath', 'newpath'),
+                ('file', 'file'), (True, True))]
         self.assertEqual([], list(filter_excluded(changes, ['newpath'])))
 
     def test_delete_file_excluded(self):
         changes = [
-            ('fid', ('somepath', None),
-             0, (False, None), ('pid', None), ('newpath', None),
-             ('file', None), (True, None))]
+            TreeChange(
+                'fid', ('somepath', None),
+                0, (False, None), ('pid', None), ('newpath', None),
+                ('file', None), (True, None))]
         self.assertEqual([], list(filter_excluded(changes, ['somepath'])))
 
     def test_move_from_or_to_excluded(self):
         changes = [
-            ('fid', ('oldpath', 'newpath'),
-             0, (False, False), ('pid', 'pid'), ('oldpath', 'newpath'),
-             ('file', 'file'), (True, True))]
+            TreeChange(
+                'fid', ('oldpath', 'newpath'),
+                0, (False, False), ('pid', 'pid'), ('oldpath', 'newpath'),
+                ('file', 'file'), (True, True))]
         self.assertEqual([], list(filter_excluded(changes, ['oldpath'])))
         self.assertEqual([], list(filter_excluded(changes, ['newpath'])))
 
=== modified file 'breezy/tests/test_transform.py'
--- breezy/tests/test_transform.py	2019-06-03 23:45:30 +0000
+++ breezy/tests/test_transform.py	2019-06-15 17:35:57 +0000
@@ -2838,7 +2838,7 @@
         self.addCleanup(preview.finalize)
         preview.delete_versioned(preview.trans_id_tree_path('foo'))
         preview_tree = preview.get_preview_tree()
-        out = StringIO()
+        out = BytesIO()
         log = BytesIO()
         trace.push_log_file(log)
         os_symlink = getattr(os, 'symlink', None)
@@ -2847,8 +2847,7 @@
             show_diff_trees(revision_tree, preview_tree, out)
             lines = out.getvalue().splitlines()
         finally:
-            if os_symlink:
-                os.symlink = os_symlink
+            os.symlink = os_symlink
         self.assertContainsRe(
             log.getvalue(),
             b'Ignoring "foo" as symlinks are not supported on this filesystem')
 
=== modified file 'breezy/transform.py'
--- breezy/transform.py	2019-03-04 01:44:35 +0000
+++ breezy/transform.py	2019-06-15 17:35:57 +0000
@@ -71,6 +71,7 @@
     )
 from .tree import (
     find_previous_path,
+    TreeChange,
     )
 
 
@@ -1002,16 +1003,17 @@
                 and from_parent == to_parent and from_name == to_name
                     and from_executable == to_executable):
                 continue
-            results.append((file_id, (from_path, to_path), modified,
-                            (from_versioned, to_versioned),
-                            (from_parent, to_parent),
-                            (from_name, to_name),
-                            (from_kind, to_kind),
-                            (from_executable, to_executable)))
+            results.append(
+                TreeChange(
+                    file_id, (from_path, to_path), modified,
+                    (from_versioned, to_versioned),
+                    (from_parent, to_parent),
+                    (from_name, to_name),
+                    (from_kind, to_kind),
+                    (from_executable, to_executable)))
 
-        def path_key(t):
-            paths = t[1]
-            return (paths[0] or '', paths[1] or '')
+        def path_key(c):
+            return (c.path[0] or '', c.path[1] or '')
         return iter(sorted(results, key=path_key))
 
     def get_preview_tree(self):
@@ -1991,7 +1993,7 @@
         self._all_children_cache = {}
         self._path2trans_id_cache = {}
         self._final_name_cache = {}
-        self._iter_changes_cache = dict((c[0], c) for c in
+        self._iter_changes_cache = dict((c.file_id, c) for c in
                                         self._transform.iter_changes())
 
     def _content_change(self, file_id):
@@ -2413,8 +2415,8 @@
         if changes is None:
             get_old = True
         else:
-            changed_content, versioned, kind = (changes[2], changes[3],
-                                                changes[6])
+            changed_content, versioned, kind = (
+                changes.changed_content, changes.versioned, changes.kind)
             if kind[1] is None:
                 return None
             get_old = (kind[0] == 'file' and versioned[0])
@@ -2693,8 +2695,9 @@
         new_desired_files = desired_files
     else:
         iter = accelerator_tree.iter_changes(tree, include_unchanged=True)
-        unchanged = [(p[0], p[1]) for (f, p, c, v, d, n, k, e)
-                     in iter if not (c or e[0] != e[1])]
+        unchanged = [
+            change.path for change in iter
+            if not (change.changed_content or change.executable[0] != change.executable[1])]
         if accelerator_tree.supports_content_filtering():
             unchanged = [(tp, ap) for (tp, ap) in unchanged
                          if not next(accelerator_tree.iter_search_rules([ap]))]
@@ -2907,19 +2910,19 @@
         skip_root = False
     try:
         deferred_files = []
-        for id_num, (file_id, path, changed_content, versioned, parent, name,
-                     kind, executable) in enumerate(change_list):
-            target_path, wt_path = path
-            target_versioned, wt_versioned = versioned
-            target_parent, wt_parent = parent
-            target_name, wt_name = name
-            target_kind, wt_kind = kind
-            target_executable, wt_executable = executable
+        for id_num, change in enumerate(change_list):
+            file_id = change.file_id
+            target_path, wt_path = change.path
+            target_versioned, wt_versioned = change.versioned
+            target_parent, wt_parent = change.parent_id
+            target_name, wt_name = change.name
+            target_kind, wt_kind = change.kind
+            target_executable, wt_executable = change.executable
             if skip_root and wt_parent is None:
                 continue
             trans_id = tt.trans_id_file_id(file_id)
             mode_id = None
-            if changed_content:
+            if change.changed_content:
                 keep_content = False
                 if wt_kind == 'file' and (backups or target_kind is None):
                     wt_sha1 = working_tree.get_file_sha1(wt_path)
@@ -3231,18 +3234,16 @@
     """
     tt = TreeTransform(target_tree)
     try:
-        for (file_id, paths, changed_content, versioned, parent, name, kind,
-             executable) in target_tree.iter_changes(source_tree,
-                                                     include_unchanged=True):
-            if changed_content:
-                continue
-            if kind != ('file', 'file'):
-                continue
-            if executable[0] != executable[1]:
-                continue
-            trans_id = tt.trans_id_tree_path(paths[1])
+        for change in target_tree.iter_changes(source_tree, include_unchanged=True):
+            if change.changed_content:
+                continue
+            if change.kind != ('file', 'file'):
+                continue
+            if change.executable[0] != change.executable[1]:
+                continue
+            trans_id = tt.trans_id_tree_path(change.path[1])
             tt.delete_contents(trans_id)
-            tt.create_hardlink(source_tree.abspath(paths[0]), trans_id)
+            tt.create_hardlink(source_tree.abspath(change.path[0]), trans_id)
         tt.apply()
     finally:
         tt.finalize()
 
=== modified file 'breezy/tree.py'
--- breezy/tree.py	2019-06-15 15:17:02 +0000
+++ breezy/tree.py	2019-06-15 17:35:57 +0000
@@ -153,11 +153,21 @@
             return tuple(self) == other
         return False
 
+    def __lt__(self, other):
+        return tuple(self) < tuple(other)
+
     def __getitem__(self, i):
         if isinstance(i, slice):
             return tuple(self).__getitem__(i)
         return getattr(self, self.__slots__[i])
 
+    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))
+
 
 class Tree(object):
     """Abstract file tree.
@@ -1094,18 +1104,18 @@
                 new_parent_id = result[4][1]
                 precise_file_ids.add(new_parent_id)
                 if changes:
-                    if (result[6][0] == 'directory' and
-                            result[6][1] != 'directory'):
+                    if (result.kind[0] == 'directory' and
+                            result.kind[1] != 'directory'):
                         # This stopped being a directory, the old children have
                         # to be included.
                         if source_entry is None:
                             # Reusing a discarded change.
                             source_entry = self._get_entry(
-                                self.source, result[1][0])
+                                self.source, result.path[0])
                         precise_file_ids.update(
                             child.file_id
-                            for child in self.source.iter_child_entries(result[1][0]))
-                    changed_file_ids.add(result[0])
+                            for child in self.source.iter_child_entries(result.path[0]))
+                    changed_file_ids.add(result.file_id)
                     yield result
 
     def file_content_matches(