Merge lp:~jelmer/brz/preview-tree into lp:brz/3.1

[Jelmer Vernooij]

Factor out common PreviewTree functions.

Factor out common PreviewTree functions.

[Jelmer Vernooij (jelmer)]

review: Approve

=== modified file 'breezy/bzr/transform.py'
--- breezy/bzr/transform.py	2020-07-06 01:43:04 +0000
+++ breezy/bzr/transform.py	2020-07-07 22:38:02 +0000
@@ -51,6 +51,7 @@
     ImmortalLimbo,
     ReusingTransform,
     MalformedTransform,
+    PreviewTree,
     )
 from ..tree import TreeChange
 from . import (
@@ -1655,7 +1656,7 @@
         The tree is a snapshot, and altering the TreeTransform will invalidate
         it.
         """
-        return _PreviewTree(self)
+        return InventoryPreviewTree(self)
 
     def _inventory_altered(self):
         """Determine which trans_ids need new Inventory entries.
@@ -1807,22 +1808,17 @@
         raise NotImplementedError(self.new_orphan)
 
 
-class _PreviewTree(inventorytree.InventoryTree):
+class InventoryPreviewTree(PreviewTree, inventorytree.InventoryTree):
     """Partial implementation of Tree to support show_diff_trees"""
 
     def __init__(self, transform):
-        self._transform = transform
+        PreviewTree.__init__(self, transform)
         self._final_paths = FinalPaths(transform)
-        self.__by_parent = None
-        self._parent_ids = []
-        self._all_children_cache = {}
-        self._path2trans_id_cache = {}
-        self._final_name_cache = {}
         self._iter_changes_cache = {
             c.file_id: c for c in self._transform.iter_changes()}
 
     def supports_tree_reference(self):
-        # TODO(jelmer): Support tree references in _PreviewTree.
+        # TODO(jelmer): Support tree references in PreviewTree.
         # return self._transform._tree.supports_tree_reference()
         return False
 
@@ -1831,19 +1827,6 @@
         changes = self._iter_changes_cache.get(file_id)
         return (changes is not None and changes.changed_content)
 
-    def _get_repository(self):
-        repo = getattr(self._transform._tree, '_repository', None)
-        if repo is None:
-            repo = self._transform._tree.branch.repository
-        return repo
-
-    def _iter_parent_trees(self):
-        for revision_id in self.get_parent_ids():
-            try:
-                yield self.revision_tree(revision_id)
-            except errors.NoSuchRevisionInTree:
-                yield self._get_repository().revision_tree(revision_id)
-
     def _get_file_revision(self, path, file_id, vf, tree_revision):
         parent_keys = [
             (file_id, t.get_file_revision(t.id2path(file_id)))
@@ -1860,12 +1843,6 @@
         name = self._transform._limbo_name(trans_id)
         return os.lstat(name)
 
-    @property
-    def _by_parent(self):
-        if self.__by_parent is None:
-            self.__by_parent = self._transform.by_parent()
-        return self.__by_parent
-
     def _comparison_data(self, entry, path):
         kind, size, executable, link_or_sha1 = self.path_content_summary(path)
         if kind == 'missing':
@@ -1876,20 +1853,10 @@
             executable = self.is_executable(path)
         return kind, executable, None
 
-    def is_locked(self):
-        return False
-
-    def lock_read(self):
-        # Perhaps in theory, this should lock the TreeTransform?
-        return lock.LogicalLockResult(self.unlock)
-
-    def unlock(self):
-        pass
-
     @property
     def root_inventory(self):
         """This Tree does not use inventory as its backing data."""
-        raise NotImplementedError(_PreviewTree.root_inventory)
+        raise NotImplementedError(PreviewTree.root_inventory)
 
     def all_file_ids(self):
         tree_ids = set(self._transform._tree.all_file_ids())
@@ -1911,28 +1878,6 @@
 
         return tree_paths
 
-    def _path2trans_id(self, path):
-        # We must not use None here, because that is a valid value to store.
-        trans_id = self._path2trans_id_cache.get(path, object)
-        if trans_id is not object:
-            return trans_id
-        segments = osutils.splitpath(path)
-        cur_parent = self._transform.root
-        for cur_segment in segments:
-            for child in self._all_children(cur_parent):
-                final_name = self._final_name_cache.get(child)
-                if final_name is None:
-                    final_name = self._transform.final_name(child)
-                    self._final_name_cache[child] = final_name
-                if final_name == cur_segment:
-                    cur_parent = child
-                    break
-            else:
-                self._path2trans_id_cache[path] = None
-                return None
-        self._path2trans_id_cache[path] = cur_parent
-        return cur_parent
-
     def path2id(self, path):
         if isinstance(path, list):
             if path == []:
@@ -1947,17 +1892,6 @@
         except NoFinalPath:
             raise errors.NoSuchId(self, file_id)
 
-    def _all_children(self, trans_id):
-        children = self._all_children_cache.get(trans_id)
-        if children is not None:
-            return children
-        children = set(self._transform.iter_tree_children(trans_id))
-        # children in the _new_parent set are provided by _by_parent.
-        children.difference_update(self._transform._new_parent)
-        children.update(self._by_parent.get(trans_id, []))
-        self._all_children_cache[trans_id] = children
-        return children
-
     def extras(self):
         possible_extras = set(self._transform.trans_id_tree_path(p) for p
                               in self._transform._tree.extras())
@@ -2069,21 +2003,6 @@
             for path, entry in entries:
                 yield path, 'V', entry.kind, entry
 
-    def kind(self, path):
-        trans_id = self._path2trans_id(path)
-        if trans_id is None:
-            raise errors.NoSuchFile(path)
-        return self._transform.final_kind(trans_id)
-
-    def stored_kind(self, path):
-        trans_id = self._path2trans_id(path)
-        if trans_id is None:
-            raise errors.NoSuchFile(path)
-        try:
-            return self._transform._new_contents[trans_id]
-        except KeyError:
-            return self._transform._tree.stored_kind(path)
-
     def get_file_mtime(self, path):
         """See Tree.get_file_mtime"""
         file_id = self.path2id(path)
@@ -2095,77 +2014,6 @@
         trans_id = self._path2trans_id(path)
         return self._stat_limbo_file(trans_id).st_mtime
 
-    def get_file_size(self, path):
-        """See Tree.get_file_size"""
-        trans_id = self._path2trans_id(path)
-        if trans_id is None:
-            raise errors.NoSuchFile(path)
-        kind = self._transform.final_kind(trans_id)
-        if kind != 'file':
-            return None
-        if trans_id in self._transform._new_contents:
-            return self._stat_limbo_file(trans_id).st_size
-        if self.kind(path) == 'file':
-            return self._transform._tree.get_file_size(path)
-        else:
-            return None
-
-    def get_file_verifier(self, path, stat_value=None):
-        trans_id = self._path2trans_id(path)
-        if trans_id is None:
-            raise errors.NoSuchFile(path)
-        kind = self._transform._new_contents.get(trans_id)
-        if kind is None:
-            return self._transform._tree.get_file_verifier(path)
-        if kind == 'file':
-            with self.get_file(path) as fileobj:
-                return ("SHA1", osutils.sha_file(fileobj))
-
-    def get_file_sha1(self, path, stat_value=None):
-        trans_id = self._path2trans_id(path)
-        if trans_id is None:
-            raise errors.NoSuchFile(path)
-        kind = self._transform._new_contents.get(trans_id)
-        if kind is None:
-            return self._transform._tree.get_file_sha1(path)
-        if kind == 'file':
-            with self.get_file(path) as fileobj:
-                return osutils.sha_file(fileobj)
-
-    def get_reference_revision(self, path):
-        trans_id = self._path2trans_id(path)
-        if trans_id is None:
-            raise errors.NoSuchFile(path)
-        reference_revision = self._transform._new_reference_revision.get(trans_id)
-        if reference_revision is None:
-            return self._transform._tree.get_reference_revision(path)
-        return reference_revision
-
-    def is_executable(self, path):
-        trans_id = self._path2trans_id(path)
-        if trans_id is None:
-            return False
-        try:
-            return self._transform._new_executability[trans_id]
-        except KeyError:
-            try:
-                return self._transform._tree.is_executable(path)
-            except OSError as e:
-                if e.errno == errno.ENOENT:
-                    return False
-                raise
-            except errors.NoSuchFile:
-                return False
-
-    def has_filename(self, path):
-        trans_id = self._path2trans_id(path)
-        if trans_id in self._transform._new_contents:
-            return True
-        elif trans_id in self._transform._removed_contents:
-            return False
-        else:
-            return self._transform._tree.has_filename(path)
-
     def path_content_summary(self, path):
         trans_id = self._path2trans_id(path)
         tt = self._transform
@@ -2219,18 +2067,6 @@
             raise ValueError('want_unversioned is not supported')
         return self._transform.iter_changes()
 
-    def get_file(self, path):
-        """See Tree.get_file"""
-        file_id = self.path2id(path)
-        if not self._content_change(file_id):
-            return self._transform._tree.get_file(path)
-        trans_id = self._path2trans_id(path)
-        name = self._transform._limbo_name(trans_id)
-        return open(name, 'rb')
-
-    def get_file_with_stat(self, path):
-        return self.get_file(path), None
-
     def annotate_iter(self, path,
                       default_revision=_mod_revision.CURRENT_REVISION):
         file_id = self.path2id(path)
@@ -2263,15 +2099,6 @@
                                    self.get_file(path).readlines(),
                                    default_revision)
 
-    def get_symlink_target(self, path):
-        """See Tree.get_symlink_target"""
-        file_id = self.path2id(path)
-        if not self._content_change(file_id):
-            return self._transform._tree.get_symlink_target(path)
-        trans_id = self._path2trans_id(path)
-        name = self._transform._limbo_name(trans_id)
-        return osutils.readlink(name)
-
     def walkdirs(self, prefix=''):
         pending = [self._transform.root]
         while len(pending) > 0:
@@ -2302,14 +2129,20 @@
             pending.extend(sorted(subdirs, key=self._final_paths.get_path,
                                   reverse=True))
 
-    def get_parent_ids(self):
-        return self._parent_ids
-
-    def set_parent_ids(self, parent_ids):
-        self._parent_ids = parent_ids
-
-    def get_revision_tree(self, revision_id):
-        return self._transform._tree.get_revision_tree(revision_id)
-
-
-
+    def get_symlink_target(self, path):
+        """See Tree.get_symlink_target"""
+        file_id = self.path2id(path)
+        if not self._content_change(file_id):
+            return self._transform._tree.get_symlink_target(path)
+        trans_id = self._path2trans_id(path)
+        name = self._transform._limbo_name(trans_id)
+        return osutils.readlink(name)
+
+    def get_file(self, path):
+        """See Tree.get_file"""
+        file_id = self.path2id(path)
+        if not self._content_change(file_id):
+            return self._transform._tree.get_file(path)
+        trans_id = self._path2trans_id(path)
+        name = self._transform._limbo_name(trans_id)
+        return open(name, 'rb')

=== modified file 'breezy/tests/per_tree/test_path_content_summary.py'
--- breezy/tests/per_tree/test_path_content_summary.py	2020-07-04 12:29:00 +0000
+++ breezy/tests/per_tree/test_path_content_summary.py	2020-07-07 22:38:02 +0000
@@ -23,8 +23,8 @@
     tests,
     )
 
-from breezy.bzr.transform import (
-    _PreviewTree,
+from breezy.transform import (
+    PreviewTree,
     )
 from breezy.tests import (
     features,
@@ -114,7 +114,7 @@
             self.assertEqual('missing', summary[0])
             self.assertIs(None, summary[2])
             self.assertIs(None, summary[3])
-        elif isinstance(tree, _PreviewTree):
+        elif isinstance(tree, PreviewTree):
             self.expectFailure('PreviewTree returns "missing" for unversioned'
                                'files', self.assertEqual, 'file', summary[0])
             self.assertEqual('file', summary[0])

=== modified file 'breezy/tests/per_tree/test_symlinks.py'
--- breezy/tests/per_tree/test_symlinks.py	2020-06-30 20:39:13 +0000
+++ breezy/tests/per_tree/test_symlinks.py	2020-07-07 22:38:02 +0000
@@ -27,7 +27,7 @@
     )
 from breezy.mutabletree import MutableTree
 from breezy.tests import TestSkipped
-from breezy.bzr.transform import _PreviewTree
+from breezy.transform import PreviewTree
 from breezy.tests import (
     features,
     )
@@ -55,7 +55,7 @@
         self.addCleanup(self.tree.unlock)
 
     def test_symlink_target(self):
-        if isinstance(self.tree, (MutableTree, _PreviewTree)):
+        if isinstance(self.tree, (MutableTree, PreviewTree)):
             raise TestSkipped(
                 'symlinks not accurately represented in working trees and'
                 ' preview trees')

=== modified file 'breezy/tests/per_workingtree/test_transform.py'
--- breezy/tests/per_workingtree/test_transform.py	2020-07-06 01:43:04 +0000
+++ breezy/tests/per_workingtree/test_transform.py	2020-07-07 22:38:02 +0000
@@ -1140,7 +1140,7 @@
         self.assertEqual([bar1_abspath], stat_paths)
 
     def test_iter_changes(self):
-        self.wt.set_root_id(b'eert_toor')
+        root_id = self.wt.path2id('')
         transform, root = self.transform()
         transform.new_file('old', root, [b'blah'], b'id-1', True)
         transform.apply()
@@ -1150,13 +1150,13 @@
             old = transform.trans_id_tree_path('old')
             transform.unversion_file(old)
             self.assertEqual([(b'id-1', ('old', None), False, (True, False),
-                               (b'eert_toor', b'eert_toor'),
+                               (root_id, root_id),
                                ('old', 'old'), ('file', 'file'),
                                (True, True), False)],
                              list(transform.iter_changes()))
             transform.new_directory('new', root, b'id-1')
             self.assertEqual([(b'id-1', ('old', 'new'), True, (True, True),
-                               (b'eert_toor', b'eert_toor'), ('old', 'new'),
+                               (root_id, root_id), ('old', 'new'),
                                ('file', 'directory'),
                                (True, False), False)],
                              list(transform.iter_changes()))
@@ -1164,7 +1164,7 @@
             transform.finalize()
 
     def test_iter_changes_new(self):
-        self.wt.set_root_id(b'eert_toor')
+        root_id = self.wt.path2id('')
         transform, root = self.transform()
         transform.new_file('old', root, [b'blah'])
         transform.apply()
@@ -1173,7 +1173,7 @@
             old = transform.trans_id_tree_path('old')
             transform.version_file(old, file_id=b'id-1')
             self.assertEqual([(b'id-1', (None, 'old'), False, (False, True),
-                               (b'eert_toor', b'eert_toor'),
+                               (root_id, root_id),
                                ('old', 'old'), ('file', 'file'),
                                (False, False), False)],
                              list(transform.iter_changes()))
@@ -1181,7 +1181,7 @@
             transform.finalize()
 
     def test_iter_changes_modifications(self):
-        self.wt.set_root_id(b'eert_toor')
+        root_id = self.wt.path2id('')
         transform, root = self.transform()
         transform.new_file('old', root, [b'blah'], b'id-1')
         transform.new_file('new', root, [b'blah'])
@@ -1197,7 +1197,7 @@
             # content deletion
             transform.delete_contents(old)
             self.assertEqual([(b'id-1', ('old', 'old'), True, (True, True),
-                               (b'eert_toor', b'eert_toor'),
+                               (root_id, root_id),
                                ('old', 'old'), ('file', None),
                                (False, False), False)],
                              list(transform.iter_changes()))
@@ -1205,13 +1205,13 @@
             # content change
             transform.create_file([b'blah'], old)
             self.assertEqual([(b'id-1', ('old', 'old'), True, (True, True),
-                               (b'eert_toor', b'eert_toor'),
+                               (root_id, root_id),
                                ('old', 'old'), ('file', 'file'),
                                (False, False), False)],
                              list(transform.iter_changes()))
             transform.cancel_deletion(old)
             self.assertEqual([(b'id-1', ('old', 'old'), True, (True, True),
-                               (b'eert_toor', b'eert_toor'),
+                               (root_id, root_id),
                                ('old', 'old'), ('file', 'file'),
                                (False, False), False)],
                              list(transform.iter_changes()))
@@ -1223,7 +1223,7 @@
             transform.version_file(new, file_id=b'id-1')
             transform.adjust_path('old', root, new)
             self.assertEqual([(b'id-1', ('old', 'old'), True, (True, True),
-                               (b'eert_toor', b'eert_toor'),
+                               (root_id, root_id),
                                ('old', 'old'), ('file', 'file'),
                                (False, False), False)],
                              list(transform.iter_changes()))
@@ -1234,7 +1234,7 @@
             self.assertEqual([], list(transform.iter_changes()))
             transform.set_executability(True, old)
             self.assertEqual([(b'id-1', ('old', 'old'), False, (True, True),
-                               (b'eert_toor', b'eert_toor'),
+                               (root_id, root_id),
                                ('old', 'old'), ('file', 'file'),
                                (False, True), False)],
                              list(transform.iter_changes()))
@@ -1245,7 +1245,7 @@
             transform.adjust_path('new', root, old)
             transform._new_parent = {}
             self.assertEqual([(b'id-1', ('old', 'new'), False, (True, True),
-                               (b'eert_toor', b'eert_toor'),
+                               (root_id, root_id),
                                ('old', 'new'), ('file', 'file'),
                                (False, False), False)],
                              list(transform.iter_changes()))
@@ -1256,8 +1256,7 @@
             transform.adjust_path('new', subdir, old)
             transform._new_name = {}
             self.assertEqual([(b'id-1', ('old', 'subdir/old'), False,
-                               (True, True), (b'eert_toor',
-                                              b'subdir-id'), ('old', 'old'),
+                               (True, True), (root_id, b'subdir-id'), ('old', 'old'),
                                ('file', 'file'), (False, False), False)],
                              list(transform.iter_changes()))
             transform._new_path = {}
@@ -1266,7 +1265,7 @@
             transform.finalize()
 
     def test_iter_changes_modified_bleed(self):
-        self.wt.set_root_id(b'eert_toor')
+        root_id = self.wt.path2id('')
         """Modified flag should not bleed from one change to another"""
         # unfortunately, we have no guarantee that file1 (which is modified)
         # will be applied before file2.  And if it's applied after file2, it
@@ -1283,10 +1282,10 @@
                                         transform.trans_id_file_id(b'id-2'))
             self.assertEqual(
                 [(b'id-1', (u'file1', u'file1'), True, (True, True),
-                 (b'eert_toor', b'eert_toor'), ('file1', u'file1'),
+                 (root_id, root_id), ('file1', u'file1'),
                  ('file', None), (False, False), False),
                  (b'id-2', (u'file2', u'file2'), False, (True, True),
-                 (b'eert_toor', b'eert_toor'), ('file2', u'file2'),
+                 (root_id, root_id), ('file2', u'file2'),
                  ('file', 'file'), (False, True), False)],
                 list(transform.iter_changes()))
         finally:
@@ -1294,7 +1293,7 @@
 
     def test_iter_changes_move_missing(self):
         """Test moving ids with no files around"""
-        self.wt.set_root_id(b'toor_eert')
+        root_id = self.wt.path2id('')
         # Need two steps because versioning a non-existant file is a conflict.
         transform, root = self.transform()
         transform.new_directory('floater', root, b'floater-id')
@@ -1308,7 +1307,7 @@
             transform.adjust_path('flitter', root, floater)
             self.assertEqual([(b'floater-id', ('floater', 'flitter'), False,
                                (True, True),
-                               (b'toor_eert', b'toor_eert'),
+                               (root_id, root_id),
                                ('floater', 'flitter'),
                                (None, None), (False, False), False)],
                              list(transform.iter_changes()))
@@ -1317,7 +1316,6 @@
 
     def test_iter_changes_pointless(self):
         """Ensure that no-ops are not treated as modifications"""
-        self.wt.set_root_id(b'eert_toor')
         transform, root = self.transform()
         transform.new_file('old', root, [b'blah'], b'id-1')
         transform.new_directory('subdir', root, b'subdir-id')

=== modified file 'breezy/transform.py'
--- breezy/transform.py	2020-07-06 01:43:04 +0000
+++ breezy/transform.py	2020-07-07 22:38:02 +0000
@@ -26,6 +26,7 @@
     controldir,
     errors,
     lazy_import,
+    lock,
     osutils,
     registry,
     trace,
@@ -1350,3 +1351,184 @@
             tt.delete_contents(trans_id)
             tt.create_hardlink(source_tree.abspath(change.path[0]), trans_id)
         tt.apply()
+
+
+class PreviewTree(object):
+    """Preview tree."""
+
+    def __init__(self, transform):
+        self._transform = transform
+        self._parent_ids = []
+        self.__by_parent = None
+        self._path2trans_id_cache = {}
+        self._all_children_cache = {}
+        self._final_name_cache = {}
+
+    @property
+    def _by_parent(self):
+        if self.__by_parent is None:
+            self.__by_parent = self._transform.by_parent()
+        return self.__by_parent
+
+    def get_parent_ids(self):
+        return self._parent_ids
+
+    def set_parent_ids(self, parent_ids):
+        self._parent_ids = parent_ids
+
+    def get_revision_tree(self, revision_id):
+        return self._transform._tree.get_revision_tree(revision_id)
+
+    def is_locked(self):
+        return False
+
+    def lock_read(self):
+        # Perhaps in theory, this should lock the TreeTransform?
+        return lock.LogicalLockResult(self.unlock)
+
+    def unlock(self):
+        pass
+
+    def _path2trans_id(self, path):
+        # We must not use None here, because that is a valid value to store.
+        trans_id = self._path2trans_id_cache.get(path, object)
+        if trans_id is not object:
+            return trans_id
+        segments = osutils.splitpath(path)
+        cur_parent = self._transform.root
+        for cur_segment in segments:
+            for child in self._all_children(cur_parent):
+                final_name = self._final_name_cache.get(child)
+                if final_name is None:
+                    final_name = self._transform.final_name(child)
+                    self._final_name_cache[child] = final_name
+                if final_name == cur_segment:
+                    cur_parent = child
+                    break
+            else:
+                self._path2trans_id_cache[path] = None
+                return None
+        self._path2trans_id_cache[path] = cur_parent
+        return cur_parent
+
+    def _all_children(self, trans_id):
+        children = self._all_children_cache.get(trans_id)
+        if children is not None:
+            return children
+        children = set(self._transform.iter_tree_children(trans_id))
+        # children in the _new_parent set are provided by _by_parent.
+        children.difference_update(self._transform._new_parent)
+        children.update(self._by_parent.get(trans_id, []))
+        self._all_children_cache[trans_id] = children
+        return children
+
+    def get_file_with_stat(self, path):
+        return self.get_file(path), None
+
+    def is_executable(self, path):
+        trans_id = self._path2trans_id(path)
+        if trans_id is None:
+            return False
+        try:
+            return self._transform._new_executability[trans_id]
+        except KeyError:
+            try:
+                return self._transform._tree.is_executable(path)
+            except OSError as e:
+                if e.errno == errno.ENOENT:
+                    return False
+                raise
+            except errors.NoSuchFile:
+                return False
+
+    def has_filename(self, path):
+        trans_id = self._path2trans_id(path)
+        if trans_id in self._transform._new_contents:
+            return True
+        elif trans_id in self._transform._removed_contents:
+            return False
+        else:
+            return self._transform._tree.has_filename(path)
+
+    def get_file_sha1(self, path, stat_value=None):
+        trans_id = self._path2trans_id(path)
+        if trans_id is None:
+            raise errors.NoSuchFile(path)
+        kind = self._transform._new_contents.get(trans_id)
+        if kind is None:
+            return self._transform._tree.get_file_sha1(path)
+        if kind == 'file':
+            with self.get_file(path) as fileobj:
+                return osutils.sha_file(fileobj)
+
+    def get_file_verifier(self, path, stat_value=None):
+        trans_id = self._path2trans_id(path)
+        if trans_id is None:
+            raise errors.NoSuchFile(path)
+        kind = self._transform._new_contents.get(trans_id)
+        if kind is None:
+            return self._transform._tree.get_file_verifier(path)
+        if kind == 'file':
+            with self.get_file(path) as fileobj:
+                return ("SHA1", osutils.sha_file(fileobj))
+
+    def kind(self, path):
+        trans_id = self._path2trans_id(path)
+        if trans_id is None:
+            raise errors.NoSuchFile(path)
+        return self._transform.final_kind(trans_id)
+
+    def stored_kind(self, path):
+        trans_id = self._path2trans_id(path)
+        if trans_id is None:
+            raise errors.NoSuchFile(path)
+        try:
+            return self._transform._new_contents[trans_id]
+        except KeyError:
+            return self._transform._tree.stored_kind(path)
+
+    def _get_repository(self):
+        repo = getattr(self._transform._tree, '_repository', None)
+        if repo is None:
+            repo = self._transform._tree.branch.repository
+        return repo
+
+    def _iter_parent_trees(self):
+        for revision_id in self.get_parent_ids():
+            try:
+                yield self.revision_tree(revision_id)
+            except errors.NoSuchRevisionInTree:
+                yield self._get_repository().revision_tree(revision_id)
+
+    def get_file_size(self, path):
+        """See Tree.get_file_size"""
+        trans_id = self._path2trans_id(path)
+        if trans_id is None:
+            raise errors.NoSuchFile(path)
+        kind = self._transform.final_kind(trans_id)
+        if kind != 'file':
+            return None
+        if trans_id in self._transform._new_contents:
+            return self._stat_limbo_file(trans_id).st_size
+        if self.kind(path) == 'file':
+            return self._transform._tree.get_file_size(path)
+        else:
+            return None
+
+    def get_reference_revision(self, path):
+        trans_id = self._path2trans_id(path)
+        if trans_id is None:
+            raise errors.NoSuchFile(path)
+        reference_revision = self._transform._new_reference_revision.get(trans_id)
+        if reference_revision is None:
+            return self._transform._tree.get_reference_revision(path)
+        return reference_revision
+
+    def tree_kind(self, trans_id):
+        path = self._tree_id_paths.get(trans_id)
+        if path is None:
+            return None
+        kind = self._tree.path_content_summary(path)[0]
+        if kind == 'missing':
+            kind = None
+        return kind