Merge lp:~jelmer/brz/commit-builder-fixes into lp:~jelmer/brz/foreign

[Jelmer Vernooij]

Some fixes for the commit builder tests.

* Add some entropy to commit messages.
* Skip tests that rely on empty versioned directories

=== modified file 'Makefile'
--- Makefile	2017-11-21 01:01:11 +0000
+++ Makefile	2018-03-24 17:11:56 +0000
@@ -90,6 +90,12 @@
 	# Check that there were no errors reported.
 	subunit-stats < selftest.log
 
+check-ci: docs extensions
+	# FIXME: Remove -Wignore::FutureWarning once
+	# https://github.com/paramiko/paramiko/issues/713 is not a concern
+	# anymore -- vila 2017-05-24
+	python -Werror -Wignore::FutureWarning  -Wignore::ImportWarning -O ./brz selftest -v --parallel=fork -Oselftest.timeout=120 --subunit2
+
 # Run Python style checker (apt-get install pyflakes)
 #
 # Note that at present this gives many false warnings, because it doesn't

=== modified file 'breezy/branch.py'
--- breezy/branch.py	2018-03-04 02:57:55 +0000
+++ breezy/branch.py	2018-03-24 17:11:56 +0000
@@ -26,6 +26,7 @@
     config as _mod_config,
     debug,
     fetch,
+    memorytree,
     repository,
     revision as _mod_revision,
     tag as _mod_tag,
@@ -96,7 +97,6 @@
         self._revision_id_to_revno_cache = None
         self._partial_revision_id_to_revno_cache = {}
         self._partial_revision_history_cache = []
-        self._tags_bytes = None
         self._last_revision_info_cache = None
         self._master_branch_cache = None
         self._merge_sorted_revisions_cache = None
@@ -258,23 +258,6 @@
         a_branch = Branch.open(url, possible_transports=possible_transports)
         return a_branch.repository
 
-    def _get_tags_bytes(self):
-        """Get the bytes of a serialised tags dict.
-
-        Note that not all branches support tags, nor do all use the same tags
-        logic: this method is specific to BasicTags. Other tag implementations
-        may use the same method name and behave differently, safely, because
-        of the double-dispatch via
-        format.make_tags->tags_instance->get_tags_dict.
-
-        :return: The bytes of the tags file.
-        :seealso: Branch._set_tags_bytes.
-        """
-        with self.lock_read():
-            if self._tags_bytes is None:
-                self._tags_bytes = self._transport.get_bytes('tags')
-            return self._tags_bytes
-
     def _get_nick(self, local=False, possible_transports=None):
         config = self.get_config()
         # explicit overrides master, but don't look for master if local is True
@@ -908,15 +891,6 @@
                     if_present_ids=tags_to_fetch, find_ghosts=True).execute()
                 self.repository.fetch(old_repository, fetch_spec=fetch_spec)
 
-    def _set_tags_bytes(self, bytes):
-        """Mirror method for _get_tags_bytes.
-
-        :seealso: Branch._get_tags_bytes.
-        """
-        with self.lock_write():
-            self._tags_bytes = bytes
-            return self._transport.put_bytes('tags', bytes)
-
     def _cache_revision_history(self, rev_history):
         """Set the cached revision history to rev_history.
 
@@ -952,7 +926,6 @@
         self._merge_sorted_revisions_cache = None
         self._partial_revision_history_cache = []
         self._partial_revision_id_to_revno_cache = {}
-        self._tags_bytes = None
 
     def _gen_revision_history(self):
         """Return sequence of revision hashes on to this branch.
@@ -1513,6 +1486,13 @@
         if_present_fetch.discard(_mod_revision.NULL_REVISION)
         return must_fetch, if_present_fetch
 
+    def create_memorytree(self):
+        """Create a memory tree for this branch.
+
+        :return: An in-memory MutableTree instance
+        """
+        return memorytree.MemoryTree.create_on_branch(self)
+
 
 class BranchFormat(controldir.ControlComponentFormat):
     """An encapsulation of the initialization and open routines for a format.

=== modified file 'breezy/branchbuilder.py'
--- breezy/branchbuilder.py	2017-11-19 18:35:20 +0000
+++ breezy/branchbuilder.py	2018-03-24 17:11:56 +0000
@@ -112,7 +112,7 @@
             if base_id != self._branch.last_revision():
                 self._move_branch_pointer(base_id,
                     allow_leftmost_as_ghost=allow_leftmost_as_ghost)
-        tree = memorytree.MemoryTree.create_on_branch(self._branch)
+        tree = self._branch.create_memorytree()
         tree.lock_write()
         try:
             if parent_ids is not None:
@@ -157,7 +157,7 @@
             # We are cheating a little bit here, and locking the new tree
             # before the old tree is unlocked. But that way the branch stays
             # locked throughout.
-            new_tree = memorytree.MemoryTree.create_on_branch(self._branch)
+            new_tree = self._branch.create_memorytree()
             new_tree.lock_write()
             self._tree.unlock()
             self._tree = new_tree
@@ -172,7 +172,7 @@
         if self._tree is not None:
             raise AssertionError('You cannot start a new series while a'
                                  ' series is already going.')
-        self._tree = memorytree.MemoryTree.create_on_branch(self._branch)
+        self._tree = self._branch.create_memorytree()
         self._tree.lock_write()
 
     def finish_series(self):
@@ -223,7 +223,7 @@
         if self._tree is not None:
             tree = self._tree
         else:
-            tree = memorytree.MemoryTree.create_on_branch(self._branch)
+            tree = self._branch.create_memorytree()
         tree.lock_write()
         try:
             if parent_ids is not None:

=== modified file 'breezy/builtins.py'
--- breezy/builtins.py	2018-03-12 05:18:13 +0000
+++ breezy/builtins.py	2018-03-24 17:11:56 +0000
@@ -53,6 +53,7 @@
     symbol_versioning,
     timestamp,
     transport,
+    tree as _mod_tree,
     ui,
     urlutils,
     views,
@@ -960,11 +961,11 @@
 
         self.add_cleanup(tree.lock_read().unlock)
         if file_list is not None:
-            file_ids = tree.paths2ids(file_list, trees=extra_trees,
-                                      require_versioned=True)
+            paths = tree.find_related_paths_across_trees(
+                    file_list, extra_trees, require_versioned=True)
             # find_ids_across_trees may include some paths that don't
             # exist in 'tree'.
-            entries = tree.iter_entries_by_dir(specific_file_ids=file_ids)
+            entries = tree.iter_entries_by_dir(specific_files=paths)
         else:
             entries = tree.iter_entries_by_dir()
 
@@ -4776,29 +4777,27 @@
                                          " merges.  Not cherrypicking or"
                                          " multi-merges."))
         repository = tree.branch.repository
-        interesting_ids = None
+        interesting_files = None
         new_conflicts = []
         conflicts = tree.conflicts()
         if file_list is not None:
-            interesting_ids = set()
+            interesting_files = set()
             for filename in file_list:
-                file_id = tree.path2id(filename)
-                if file_id is None:
+                if not tree.is_versioned(filename):
                     raise errors.NotVersionedError(filename)
-                interesting_ids.add(file_id)
-                if tree.kind(filename, file_id) != "directory":
+                interesting_files.add(filename)
+                if tree.kind(filename) != "directory":
                     continue
 
-                # FIXME: Support nested trees
-                for name, ie in tree.root_inventory.iter_entries(file_id):
-                    interesting_ids.add(ie.file_id)
+                for path, ie in tree.iter_entries_by_dir(specific_files=[filename]):
+                    interesting_files.add(path)
             new_conflicts = conflicts.select_conflicts(tree, file_list)[0]
         else:
             # Remerge only supports resolving contents conflicts
             allowed_conflicts = ('text conflict', 'contents conflict')
             restore_files = [c.path for c in conflicts
                              if c.typestring in allowed_conflicts]
-        _mod_merge.transform_tree(tree, tree.basis_tree(), interesting_ids)
+        _mod_merge.transform_tree(tree, tree.basis_tree(), interesting_files)
         tree.set_conflicts(ConflictList(new_conflicts))
         if file_list is not None:
             restore_files = file_list
@@ -4815,7 +4814,7 @@
         tree.set_parent_ids(parents[:1])
         try:
             merger = _mod_merge.Merger.from_revision_ids(tree, parents[1])
-            merger.interesting_ids = interesting_ids
+            merger.interesting_files = interesting_files
             merger.merge_type = merge_type
             merger.show_base = show_base
             merger.reprocess = reprocess

=== modified file 'breezy/bzr/branch.py'
--- breezy/bzr/branch.py	2017-11-12 18:17:03 +0000
+++ breezy/bzr/branch.py	2018-03-24 17:11:56 +0000
@@ -97,6 +97,7 @@
         self.repository = _repository
         self.conf_store = None
         Branch.__init__(self, possible_transports)
+        self._tags_bytes = None
 
     def __str__(self):
         return '%s(%s)' % (self.__class__.__name__, self.user_url)
@@ -402,6 +403,36 @@
             self._format._update_feature_flags(updated_flags)
             self.control_transport.put_bytes('format', self._format.as_string())
 
+    def _get_tags_bytes(self):
+        """Get the bytes of a serialised tags dict.
+
+        Note that not all branches support tags, nor do all use the same tags
+        logic: this method is specific to BasicTags. Other tag implementations
+        may use the same method name and behave differently, safely, because
+        of the double-dispatch via
+        format.make_tags->tags_instance->get_tags_dict.
+
+        :return: The bytes of the tags file.
+        :seealso: Branch._set_tags_bytes.
+        """
+        with self.lock_read():
+            if self._tags_bytes is None:
+                self._tags_bytes = self._transport.get_bytes('tags')
+            return self._tags_bytes
+
+    def _set_tags_bytes(self, bytes):
+        """Mirror method for _get_tags_bytes.
+
+        :seealso: Branch._get_tags_bytes.
+        """
+        with self.lock_write():
+            self._tags_bytes = bytes
+            return self._transport.put_bytes('tags', bytes)
+
+    def _clear_cached_state(self):
+        super(BzrBranch, self)._clear_cached_state()
+        self._tags_bytes = None
+
 
 class BzrBranch8(BzrBranch):
     """A branch that stores tree-reference locations."""

=== modified file 'breezy/bzr/inventory.py'
--- breezy/bzr/inventory.py	2018-03-10 15:17:30 +0000
+++ breezy/bzr/inventory.py	2018-03-24 17:11:56 +0000
@@ -720,12 +720,12 @@
 
     def _preload_cache(self):
         """Populate any caches, we are about to access all items.
-        
+
         The default implementation does nothing, because CommonInventory doesn't
         have a cache.
         """
         pass
-    
+
     def iter_entries_by_dir(self, from_dir=None, specific_file_ids=None,
         yield_parents=False):
         """Iterate over the entries in a directory first order.

=== modified file 'breezy/bzr/inventorytree.py'
--- breezy/bzr/inventorytree.py	2018-03-12 05:18:13 +0000
+++ breezy/bzr/inventorytree.py	2018-03-24 17:11:56 +0000
@@ -77,7 +77,8 @@
         adjusted to account for existing elements that match case
         insensitively.
         """
-        return list(self._yield_canonical_inventory_paths(paths))
+        with self.lock_read():
+            return list(self._yield_canonical_inventory_paths(paths))
 
     def get_canonical_inventory_path(self, path):
         """Returns the first inventory item that case-insensitively matches path.
@@ -97,7 +98,8 @@
         :return: The input path adjusted to account for existing elements
         that match case insensitively.
         """
-        return next(self._yield_canonical_inventory_paths([path]))
+        with self.lock_read():
+            return next(self._yield_canonical_inventory_paths([path]))
 
     def _yield_canonical_inventory_paths(self, paths):
         for path in paths:
@@ -112,31 +114,34 @@
             for elt in bit_iter:
                 lelt = elt.lower()
                 new_path = None
-                for child in self.iter_children(cur_id):
-                    try:
-                        # XXX: it seem like if the child is known to be in the
-                        # tree, we shouldn't need to go from its id back to
-                        # its path -- mbp 2010-02-11
-                        #
-                        # XXX: it seems like we could be more efficient
-                        # by just directly looking up the original name and
-                        # only then searching all children; also by not
-                        # chopping paths so much. -- mbp 2010-02-11
-                        child_base = os.path.basename(self.id2path(child))
-                        if (child_base == elt):
-                            # if we found an exact match, we can stop now; if
-                            # we found an approximate match we need to keep
-                            # searching because there might be an exact match
-                            # later.  
-                            cur_id = child
-                            new_path = osutils.pathjoin(cur_path, child_base)
-                            break
-                        elif child_base.lower() == lelt:
-                            cur_id = child
-                            new_path = osutils.pathjoin(cur_path, child_base)
-                    except errors.NoSuchId:
-                        # before a change is committed we can see this error...
-                        continue
+                try:
+                    for child in self.iter_child_entries(self.id2path(cur_id), cur_id):
+                        try:
+                            # XXX: it seem like if the child is known to be in the
+                            # tree, we shouldn't need to go from its id back to
+                            # its path -- mbp 2010-02-11
+                            #
+                            # XXX: it seems like we could be more efficient
+                            # by just directly looking up the original name and
+                            # only then searching all children; also by not
+                            # chopping paths so much. -- mbp 2010-02-11
+                            child_base = os.path.basename(self.id2path(child.file_id))
+                            if (child_base == elt):
+                                # if we found an exact match, we can stop now; if
+                                # we found an approximate match we need to keep
+                                # searching because there might be an exact match
+                                # later.  
+                                cur_id = child.file_id
+                                new_path = osutils.pathjoin(cur_path, child_base)
+                                break
+                            elif child_base.lower() == lelt:
+                                cur_id = child.file_id
+                                new_path = osutils.pathjoin(cur_path, child_base)
+                        except errors.NoSuchId:
+                            # before a change is committed we can see this error...
+                            continue
+                except errors.NotADirectory:
+                    pass
                 if new_path:
                     cur_path = new_path
                 else:
@@ -165,6 +170,53 @@
             file_id = file_id[0]
         return self.root_inventory, file_id
 
+    def find_related_paths_across_trees(self, paths, trees=[],
+            require_versioned=True):
+        """Find related paths in tree corresponding to specified filenames in any
+        of `lookup_trees`.
+
+        All matches in all trees will be used, and all children of matched
+        directories will be used.
+
+        :param paths: The filenames to find related paths for (if None, returns
+            None)
+        :param trees: The trees to find file_ids within
+        :param require_versioned: if true, all specified filenames must occur in
+            at least one tree.
+        :return: a set of paths for the specified filenames and their children
+            in `tree`
+        """
+        if paths is None:
+            return None;
+        file_ids = self.paths2ids(
+                paths, trees, require_versioned=require_versioned)
+        ret = set()
+        for file_id in file_ids:
+            try:
+                ret.add(self.id2path(file_id))
+            except errors.NoSuchId:
+                pass
+        return ret
+
+    def paths2ids(self, paths, trees=[], require_versioned=True):
+        """Return all the ids that can be reached by walking from paths.
+
+        Each path is looked up in this tree and any extras provided in
+        trees, and this is repeated recursively: the children in an extra tree
+        of a directory that has been renamed under a provided path in this tree
+        are all returned, even if none exist under a provided path in this
+        tree, and vice versa.
+
+        :param paths: An iterable of paths to start converting to ids from.
+            Alternatively, if paths is None, no ids should be calculated and None
+            will be returned. This is offered to make calling the api unconditional
+            for code that *might* take a list of files.
+        :param trees: Additional trees to consider.
+        :param require_versioned: If False, do not raise NotVersionedError if
+            an element of paths is not versioned in this tree and all of trees.
+        """
+        return find_ids_across_trees(paths, [self] + list(trees), require_versioned)
+
     def path2id(self, path):
         """Return the id for path in this tree."""
         with self.lock_read():
@@ -217,7 +269,7 @@
         # are not versioned.
         return set((p for p in paths if self.path2id(p) is None))
 
-    def iter_entries_by_dir(self, specific_file_ids=None, yield_parents=False):
+    def iter_entries_by_dir(self, specific_files=None, yield_parents=False):
         """Walk the tree in 'by_dir' order.
 
         This will yield each entry in the tree as a (path, entry) tuple.
@@ -226,20 +278,20 @@
         See Tree.iter_entries_by_dir for details.
 
         :param yield_parents: If True, yield the parents from the root leading
-            down to specific_file_ids that have been requested. This has no
-            impact if specific_file_ids is None.
+            down to specific_files that have been requested. This has no
+            impact if specific_files is None.
         """
         with self.lock_read():
-            if specific_file_ids is None:
-                inventory_file_ids = None
-            else:
+            if specific_files is not None:
                 inventory_file_ids = []
-                for tree_file_id in specific_file_ids:
-                    inventory, inv_file_id = self._unpack_file_id(tree_file_id)
+                for path in specific_files:
+                    inventory, inv_file_id = self._path2inv_file_id(path)
                     if not inventory is self.root_inventory: # for now
                         raise AssertionError("%r != %r" % (
                             inventory, self.root_inventory))
                     inventory_file_ids.append(inv_file_id)
+            else:
+                inventory_file_ids = None
             # FIXME: Handle nested trees
             return self.root_inventory.iter_entries_by_dir(
                 specific_file_ids=inventory_file_ids, yield_parents=yield_parents)
@@ -248,15 +300,13 @@
         with self.lock_read():
             inv, inv_file_id = self._path2inv_file_id(path, file_id)
             try:
-                return iter(viewvalues(inv[inv_file_id].children))
+                ie = inv[inv_file_id]
             except errors.NoSuchId:
                 raise errors.NoSuchFile(path)
-
-    def iter_children(self, file_id, path=None):
-        """See Tree.iter_children."""
-        entry = self.iter_entries_by_dir([file_id]).next()[1]
-        for child in viewvalues(getattr(entry, 'children', {})):
-            yield child.file_id
+            else:
+                if ie.kind != 'directory':
+                    raise errors.NotADirectory(path)
+                return iter(viewvalues(ie.children))
 
     def _get_plan_merge_data(self, file_id, other, base):
         from . import versionedfile
@@ -316,6 +366,84 @@
         return last_revision
 
 
+def find_ids_across_trees(filenames, trees, require_versioned=True):
+    """Find the ids corresponding to specified filenames.
+
+    All matches in all trees will be used, and all children of matched
+    directories will be used.
+
+    :param filenames: The filenames to find file_ids for (if None, returns
+        None)
+    :param trees: The trees to find file_ids within
+    :param require_versioned: if true, all specified filenames must occur in
+        at least one tree.
+    :return: a set of file ids for the specified filenames and their children.
+    """
+    if not filenames:
+        return None
+    specified_path_ids = _find_ids_across_trees(filenames, trees,
+        require_versioned)
+    return _find_children_across_trees(specified_path_ids, trees)
+
+
+def _find_ids_across_trees(filenames, trees, require_versioned):
+    """Find the ids corresponding to specified filenames.
+
+    All matches in all trees will be used, but subdirectories are not scanned.
+
+    :param filenames: The filenames to find file_ids for
+    :param trees: The trees to find file_ids within
+    :param require_versioned: if true, all specified filenames must occur in
+        at least one tree.
+    :return: a set of file ids for the specified filenames
+    """
+    not_versioned = []
+    interesting_ids = set()
+    for tree_path in filenames:
+        not_found = True
+        for tree in trees:
+            file_id = tree.path2id(tree_path)
+            if file_id is not None:
+                interesting_ids.add(file_id)
+                not_found = False
+        if not_found:
+            not_versioned.append(tree_path)
+    if len(not_versioned) > 0 and require_versioned:
+        raise errors.PathsNotVersionedError(not_versioned)
+    return interesting_ids
+
+
+def _find_children_across_trees(specified_ids, trees):
+    """Return a set including specified ids and their children.
+
+    All matches in all trees will be used.
+
+    :param trees: The trees to find file_ids within
+    :return: a set containing all specified ids and their children
+    """
+    interesting_ids = set(specified_ids)
+    pending = interesting_ids
+    # now handle children of interesting ids
+    # we loop so that we handle all children of each id in both trees
+    while len(pending) > 0:
+        new_pending = set()
+        for file_id in pending:
+            for tree in trees:
+                try:
+                    path = tree.id2path(file_id)
+                except errors.NoSuchId:
+                    continue
+                try:
+                    for child in tree.iter_child_entries(path, file_id):
+                        if child.file_id not in interesting_ids:
+                            new_pending.add(child.file_id)
+                except errors.NotADirectory:
+                    pass
+        interesting_ids.update(new_pending)
+        pending = new_pending
+    return interesting_ids
+
+
 class MutableInventoryTree(MutableTree, InventoryTree):
 
     def apply_inventory_delta(self, changes):
@@ -439,10 +567,11 @@
             return entry[3]
         # Find a 'best fit' match if the filesystem is case-insensitive
         inv_path = self.tree._fix_case_of_inventory_path(inv_path)
-        file_id = self.tree.path2id(inv_path)
-        if file_id is not None:
-            return self.tree.iter_entries_by_dir([file_id]).next()[1]
-        return None
+        try:
+            return self.tree.iter_entries_by_dir(
+                    specific_files=[inv_path]).next()[1]
+        except StopIteration:
+            return None
 
     def _convert_to_directory(self, this_ie, inv_path):
         """Convert an entry to a directory.
@@ -749,7 +878,10 @@
 
     def kind(self, path, file_id=None):
         inv, inv_file_id = self._path2inv_file_id(path, file_id)
-        return inv[inv_file_id].kind
+        try:
+            return inv[inv_file_id].kind
+        except errors.NoSuchId:
+            raise errors.NoSuchFile(path)
 
     def path_content_summary(self, path):
         """See Tree.path_content_summary."""

=== modified file 'breezy/bzr/remote.py'
--- breezy/bzr/remote.py	2018-03-12 05:58:54 +0000
+++ breezy/bzr/remote.py	2018-03-24 17:11:56 +0000
@@ -3441,6 +3441,7 @@
 
     def _clear_cached_state(self):
         super(RemoteBranch, self)._clear_cached_state()
+        self._tags_bytes = None
         if self._real_branch is not None:
             self._real_branch._clear_cached_state()
 

=== modified file 'breezy/bzr/workingtree.py'
--- breezy/bzr/workingtree.py	2018-03-04 19:11:38 +0000
+++ breezy/bzr/workingtree.py	2018-03-24 17:11:56 +0000
@@ -652,10 +652,7 @@
         file_ids are in a WorkingTree if they are in the working inventory
         and the working file exists.
         """
-        ret = set()
-        for path, ie in self.iter_entries_by_dir():
-            ret.add(ie.file_id)
-        return ret
+        return {ie.file_id for path, ie in self.iter_entries_by_dir()}
 
     def all_versioned_paths(self):
         return {path for path, ie in self.iter_entries_by_dir()}
@@ -828,7 +825,7 @@
 
                     try:
                         kind = parent_tree.kind(path, file_id)
-                    except errors.NoSuchId:
+                    except errors.NoSuchFile:
                         continue
                     if kind != 'file':
                         # Note: this is slightly unnecessary, because symlinks and
@@ -1699,13 +1696,13 @@
                 blocked_parent_ids.add(ie.file_id)
             yield path, ie
 
-    def iter_entries_by_dir(self, specific_file_ids=None, yield_parents=False):
+    def iter_entries_by_dir(self, specific_files=None,
+                            yield_parents=False):
         """See Tree.iter_entries_by_dir()"""
         # The only trick here is that if we supports_tree_reference then we
         # need to detect if a directory becomes a tree-reference.
         iterator = super(WorkingTree, self).iter_entries_by_dir(
-                specific_file_ids=specific_file_ids,
-                yield_parents=yield_parents)
+                specific_files=specific_files, yield_parents=yield_parents)
         if not self.supports_tree_reference():
             return iterator
         else:

=== modified file 'breezy/bzr/workingtree_4.py'
--- breezy/bzr/workingtree_4.py	2018-03-12 05:18:13 +0000
+++ breezy/bzr/workingtree_4.py	2018-03-24 17:11:56 +0000
@@ -1963,7 +1963,7 @@
     def kind(self, path, file_id=None):
         entry = self._get_entry(file_id=file_id, path=path)[1]
         if entry is None:
-            raise errors.NoSuchId(tree=self, file_id=file_id)
+            raise errors.NoSuchFile(path)
         parent_index = self._get_parent_index()
         return dirstate.DirState._minikind_to_kind[entry[parent_index][0]]
 

=== modified file 'breezy/config.py'
--- breezy/config.py	2017-10-26 11:10:38 +0000
+++ breezy/config.py	2018-03-24 17:11:56 +0000
@@ -2706,7 +2706,7 @@
 Whether revisions associated with tags should be fetched.
 """))
 option_registry.register_lazy(
-    'bzr.transform.orphan_policy', 'breezy.transform', 'opt_transform_orphan')
+    'transform.orphan_policy', 'breezy.transform', 'opt_transform_orphan')
 option_registry.register(
     Option('bzr.workingtree.worth_saving_limit', default=10,
            from_unicode=int_from_store,  invalid='warning',

=== modified file 'breezy/filter_tree.py'
--- breezy/filter_tree.py	2017-11-12 17:53:35 +0000
+++ breezy/filter_tree.py	2018-03-24 17:11:56 +0000
@@ -47,7 +47,7 @@
     def get_file_text(self, path, file_id=None):
         chunks = self.backing_tree.get_file_lines(path, file_id)
         filters = self.filter_stack_callback(path)
-        context = ContentFilterContext(path, self, None)
+        context = ContentFilterContext(path, self)
         contents = filtered_output_bytes(chunks, filters, context)
         content = ''.join(contents)
         return content
@@ -58,14 +58,14 @@
     def is_executable(self, path, file_id=None):
         return self.backing_tree.is_executable(path, file_id)
 
-    def iter_entries_by_dir(self, specific_file_ids=None, yield_parents=None):
+    def iter_entries_by_dir(self, specific_files=None, yield_parents=None):
         # NB: This simply returns the parent tree's entries; the length may be
         # wrong but it can't easily be calculated without filtering the whole
         # text.  Currently all callers cope with this; perhaps they should be
         # updated to a narrower interface that only provides things guaranteed
         # cheaply available across all trees. -- mbp 20110705
         return self.backing_tree.iter_entries_by_dir(
-            specific_file_ids=specific_file_ids,
+            specific_files=specific_files,
             yield_parents=yield_parents)
 
     def lock_read(self):

=== modified file 'breezy/filters/__init__.py'
--- breezy/filters/__init__.py	2017-11-12 13:53:51 +0000
+++ breezy/filters/__init__.py	2018-03-24 17:11:56 +0000
@@ -72,19 +72,16 @@
 class ContentFilterContext(object):
     """Object providing information that filters can use."""
 
-    def __init__(self, relpath=None, tree=None, entry=None):
+    def __init__(self, relpath=None, tree=None):
         """Create a context.
 
         :param relpath: the relative path or None if this context doesn't
            support that information.
         :param tree: the Tree providing this file or None if this context
            doesn't support that information.
-        :param entry: the InventoryEntry object if it is already known or
-           None if it should be derived if possible
         """
         self._relpath = relpath
         self._tree = tree
-        self._entry = entry
         # Cached values
         self._revision_id = None
         self._revision = None
@@ -97,24 +94,12 @@
         """Source Tree object."""
         return self._tree
 
-    def file_id(self):
-        """File-id of file."""
-        if self._entry is not None:
-            return self._entry.file_id
-        elif self._tree is None:
-            return None
-        else:
-            return self._tree.path2id(self._relpath)
-
     def revision_id(self):
         """Id of revision that last changed this file."""
         if self._revision_id is None:
-            if self._entry is not None:
-                self._revision_id = self._entry.revision
-            elif self._tree is not None:
-                file_id = self._tree.path2id(self._relpath)
-                self._entry = self._tree.inventory[file_id]
-                self._revision_id = self._entry.revision
+            if self._tree is not None:
+                self._revision_id = self._tree.get_file_revision(
+                        self._relpath)
         return self._revision_id
 
     def revision(self):

=== modified file 'breezy/gpg.py'
--- breezy/gpg.py	2018-03-12 05:59:58 +0000
+++ breezy/gpg.py	2018-03-24 17:11:56 +0000
@@ -193,12 +193,15 @@
         try:
             import gpg
             self.context = gpg.Context()
-            self.context.armor = True
+<<<<<<< TREE
+            self.context.armor = True
+=======
+            self.context.armor = True
+            self.context.signers = self._get_signing_keys()
+>>>>>>> MERGE-SOURCE
         except ImportError as error:
             pass # can't use verify()
 
-        self.context.signers = self._get_signing_keys()
-
     def _get_signing_keys(self):
         import gpg
         keyname = self._config_stack.get('gpg_signing_key')

=== modified file 'breezy/log.py'
--- breezy/log.py	2018-03-12 05:56:13 +0000
+++ breezy/log.py	2018-03-24 17:11:56 +0000
@@ -64,7 +64,6 @@
     config,
     controldir,
     diff,
-    errors,
     foreign,
     repository as _mod_repository,
     revision as _mod_revision,
@@ -74,6 +73,7 @@
 """)
 
 from . import (
+    errors,
     lazy_regex,
     registry,
     revisionspec,

=== modified file 'breezy/memorytree.py'
--- breezy/memorytree.py	2018-03-12 02:03:26 +0000
+++ breezy/memorytree.py	2018-03-24 17:11:56 +0000
@@ -270,7 +270,12 @@
             # is not relevant to memory tree. Until that is done in unlock by
             # working tree, we cannot share the implementation.
             if file_ids is None:
-                file_ids = {self.path2id(path) for path in paths}
+                file_ids = set()
+                for path in paths:
+                    file_id = self.path2id(path)
+                    if file_id is None:
+                        raise errors.NoSuchFile(path)
+                    file_ids.add(file_id)
             for file_id in file_ids:
                 if self._inventory.has_id(file_id):
                     self._inventory.remove_recursive_id(file_id)

=== modified file 'breezy/merge.py'
--- breezy/merge.py	2018-03-12 05:18:13 +0000
+++ breezy/merge.py	2018-03-24 17:11:56 +0000
@@ -56,12 +56,13 @@
 # TODO: Report back as changes are merged in
 
 
-def transform_tree(from_tree, to_tree, interesting_ids=None):
+def transform_tree(from_tree, to_tree, interesting_files=None):
     from_tree.lock_tree_write()
     operation = cleanup.OperationWithCleanups(merge_inner)
     operation.add_cleanup(from_tree.unlock)
     operation.run_simple(from_tree.branch, to_tree, from_tree,
-        ignore_zero=True, interesting_ids=interesting_ids, this_tree=from_tree)
+        ignore_zero=True, this_tree=from_tree,
+        interesting_files=interesting_files)
 
 
 class MergeHooks(hooks.Hooks):
@@ -130,20 +131,6 @@
         """
         raise NotImplementedError(self.file_matches)
 
-    def get_filename(self, params, tree):
-        """Lookup the filename (i.e. basename, not path), given a Tree (e.g.
-        self.merger.this_tree) and a MergeFileHookParams.
-        """
-        return osutils.basename(tree.id2path(params.file_id))
-
-    def get_filepath(self, params, tree):
-        """Calculate the path to the file in a tree.
-
-        :param params: A MergeFileHookParams describing the file to merge
-        :param tree: a Tree, e.g. self.merger.this_tree.
-        """
-        return tree.id2path(params.file_id)
-
     def merge_contents(self, params):
         """Merge the contents of a single file."""
         # Check whether this custom merge logic should be used.
@@ -216,7 +203,7 @@
                 affected_files = self.default_files
             self.affected_files = affected_files
         if affected_files:
-            filepath = self.get_filepath(params, self.merger.this_tree)
+            filepath = params.this_path
             if filepath in affected_files:
                 return True
         return False
@@ -240,16 +227,21 @@
     There are some fields hooks can access:
 
     :ivar file_id: the file ID of the file being merged
+    :ivar base_path: Path in base tree
+    :ivar other_path: Path in other tree
+    :ivar this_path: Path in this tree
     :ivar trans_id: the transform ID for the merge of this file
     :ivar this_kind: kind of file_id in 'this' tree
     :ivar other_kind: kind of file_id in 'other' tree
     :ivar winner: one of 'this', 'other', 'conflict'
     """
 
-    def __init__(self, merger, file_id, trans_id, this_kind, other_kind,
+    def __init__(self, merger, file_id, paths, trans_id, this_kind, other_kind,
             winner):
         self._merger = merger
         self.file_id = file_id
+        self.paths = paths
+        self.base_path, self.other_path, self.this_path = paths
         self.trans_id = trans_id
         self.this_kind = this_kind
         self.other_kind = other_kind
@@ -262,17 +254,17 @@
     @decorators.cachedproperty
     def base_lines(self):
         """The lines of the 'base' version of the file."""
-        return self._merger.get_lines(self._merger.base_tree, self.file_id)
+        return self._merger.get_lines(self._merger.base_tree, self.base_path, self.file_id)
 
     @decorators.cachedproperty
     def this_lines(self):
         """The lines of the 'this' version of the file."""
-        return self._merger.get_lines(self._merger.this_tree, self.file_id)
+        return self._merger.get_lines(self._merger.this_tree, self.this_path, self.file_id)
 
     @decorators.cachedproperty
     def other_lines(self):
         """The lines of the 'other' version of the file."""
-        return self._merger.get_lines(self._merger.other_tree, self.file_id)
+        return self._merger.get_lines(self._merger.other_tree, self.other_path, self.file_id)
 
 
 class Merger(object):
@@ -295,7 +287,6 @@
         self.base_tree = base_tree
         self.ignore_zero = False
         self.backup_files = False
-        self.interesting_ids = None
         self.interesting_files = None
         self.show_base = False
         self.reprocess = False
@@ -610,7 +601,6 @@
     def make_merger(self):
         kwargs = {'working_tree': self.this_tree, 'this_tree': self.this_tree,
                   'other_tree': self.other_tree,
-                  'interesting_ids': self.interesting_ids,
                   'interesting_files': self.interesting_files,
                   'this_branch': self.this_branch,
                   'other_branch': self.other_branch,
@@ -722,7 +712,7 @@
     requires_file_merge_plan = False
 
     def __init__(self, working_tree, this_tree, base_tree, other_tree,
-                 interesting_ids=None, reprocess=False, show_base=False,
+                 reprocess=False, show_base=False,
                  change_reporter=None, interesting_files=None, do_merge=True,
                  cherrypick=False, lca_trees=None, this_branch=None,
                  other_branch=None):
@@ -735,30 +725,22 @@
         :param this_branch: The branch associated with this_tree.  Defaults to
             this_tree.branch if not supplied.
         :param other_branch: The branch associated with other_tree, if any.
-        :param interesting_ids: The file_ids of files that should be
-            participate in the merge.  May not be combined with
-            interesting_files.
         :param: reprocess If True, perform conflict-reduction processing.
         :param show_base: If True, show the base revision in text conflicts.
             (incompatible with reprocess)
         :param change_reporter: An object that should report changes made
         :param interesting_files: The tree-relative paths of files that should
             participate in the merge.  If these paths refer to directories,
-            the contents of those directories will also be included.  May not
-            be combined with interesting_ids.  If neither interesting_files nor
-            interesting_ids is specified, all files may participate in the
+            the contents of those directories will also be included.  If not
+            specified, all files may participate in the
             merge.
         :param lca_trees: Can be set to a dictionary of {revision_id:rev_tree}
             if the ancestry was found to include a criss-cross merge.
             Otherwise should be None.
         """
         object.__init__(self)
-        if interesting_files is not None and interesting_ids is not None:
-            raise ValueError(
-                'specify either interesting_ids or interesting_files')
         if this_branch is None:
             this_branch = this_tree.branch
-        self.interesting_ids = interesting_ids
         self.interesting_files = interesting_files
         self.working_tree = working_tree
         self.this_tree = this_tree
@@ -830,18 +812,18 @@
         hooks = [factory(self) for factory in factories] + [self]
         self.active_hooks = [hook for hook in hooks if hook is not None]
         with ui.ui_factory.nested_progress_bar() as child_pb:
-            for num, (file_id, changed, parents3, names3,
+            for num, (file_id, changed, paths3, parents3, names3,
                       executable3) in enumerate(entries):
                 # Try merging each entry
                 child_pb.update(gettext('Preparing file merge'),
                                 num, len(entries))
-                self._merge_names(file_id, parents3, names3, resolver=resolver)
+                self._merge_names(file_id, paths3, parents3, names3, resolver=resolver)
                 if changed:
-                    file_status = self._do_merge_contents(file_id)
+                    file_status = self._do_merge_contents(paths3, file_id)
                 else:
                     file_status = 'unmodified'
-                self._merge_executable(file_id,
-                    executable3, file_status, resolver=resolver)
+                self._merge_executable(paths3, file_id, executable3,
+                        file_status, resolver=resolver)
         self.tt.fixup_new_roots()
         self._finish_computing_transform()
 
@@ -874,27 +856,32 @@
         iterator = self.other_tree.iter_changes(self.base_tree,
                 specific_files=self.interesting_files,
                 extra_trees=[self.this_tree])
-        this_entries = dict((e.file_id, e) for p, e in
-                            self.this_tree.iter_entries_by_dir(
-                            self.interesting_ids))
+        this_interesting_files = self.this_tree.find_related_paths_across_trees(
+                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 (self.interesting_ids is not None and
-                file_id not in self.interesting_ids):
-                continue
-            entry = this_entries.get(file_id)
-            if entry is not None:
-                this_name = entry.name
-                this_parent = entry.parent_id
-                this_executable = entry.executable
+            if paths[0] is not None:
+                this_path = _mod_tree.find_previous_path(
+                        self.base_tree, self.this_tree, paths[0])
+            else:
+                this_path = _mod_tree.find_previous_path(
+                        self.other_tree, self.this_tree, paths[1])
+            this_entry = this_entries.get(this_path)
+            if this_entry is not None:
+                this_name = this_entry.name
+                this_parent = this_entry.parent_id
+                this_executable = this_entry.executable
             else:
                 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, parents3, names3, executable3))
+            result.append((file_id, changed, paths3, parents3, names3, executable3))
         return result
 
     def _entries_lca(self):
@@ -905,10 +892,11 @@
 
         For the multi-valued entries, the format will be (BASE, [lca1, lca2])
 
-        :return: [(file_id, changed, parents, names, executable)], where:
+        :return: [(file_id, changed, paths, parents, names, executable)], where:
 
             * file_id: Simple file_id of the entry
             * changed: Boolean, True if the kind or contents changed else False
+            * paths: ((base, [path, in, lcas]), path_other, path_this)
             * parents: ((base, [parent_id, in, lcas]), parent_id_other,
                         parent_id_this)
             * names:   ((base, [name, in, lcas]), name_in_other, name_in_this)
@@ -919,10 +907,10 @@
             lookup_trees = [self.this_tree, self.base_tree]
             lookup_trees.extend(self._lca_trees)
             # I think we should include the lca trees as well
-            interesting_ids = self.other_tree.paths2ids(self.interesting_files,
-                                                        lookup_trees)
+            interesting_files = self.other_tree.find_related_paths_across_trees(
+                    self.interesting_files, lookup_trees)
         else:
-            interesting_ids = self.interesting_ids
+            interesting_files = None
         result = []
         walker = _mod_tree.MultiWalker(self.other_tree, self._lca_trees)
 
@@ -932,7 +920,10 @@
             # Is this modified at all from any of the other trees?
             if other_ie is None:
                 other_ie = _none_entry
-            if interesting_ids is not None and file_id not in interesting_ids:
+                other_path = None
+            else:
+                other_path = self.other_tree.id2path(file_id)
+            if interesting_files is not None and other_path not in interesting_files:
                 continue
 
             # If other_revision is found in any of the lcas, that means this
@@ -955,21 +946,30 @@
                     continue
 
             lca_entries = []
+            lca_paths = []
             for lca_path, lca_ie in lca_values:
                 if lca_ie is None:
                     lca_entries.append(_none_entry)
+                    lca_paths.append(None)
                 else:
                     lca_entries.append(lca_ie)
+                    lca_paths.append(path)
 
             try:
                 base_ie = base_inventory[file_id]
             except errors.NoSuchId:
                 base_ie = _none_entry
+                base_path = None
+            else:
+                base_path = self.base_tree.id2path(file_id)
 
             try:
                 this_ie = this_inventory[file_id]
             except errors.NoSuchId:
                 this_ie = _none_entry
+                this_path = None
+            else:
+                this_path = self.this_tree.id2path(file_id)
 
             lca_kinds = []
             lca_parent_ids = []
@@ -1000,15 +1000,18 @@
                         continue
                     content_changed = False
                 elif other_ie.kind is None or other_ie.kind == 'file':
-                    def get_sha1(ie, tree):
-                        if ie.kind != 'file':
-                            return None
-                        return tree.get_file_sha1(tree.id2path(file_id), file_id)
-                    base_sha1 = get_sha1(base_ie, self.base_tree)
-                    lca_sha1s = [get_sha1(ie, tree) for ie, tree
-                                 in zip(lca_entries, self._lca_trees)]
-                    this_sha1 = get_sha1(this_ie, self.this_tree)
-                    other_sha1 = get_sha1(other_ie, self.other_tree)
+                    def get_sha1(tree, path):
+                        if path is None:
+                            return None
+                        try:
+                            return tree.get_file_sha1(path, file_id)
+                        except errors.NoSuchFile:
+                            return None
+                    base_sha1 = get_sha1(self.base_tree, base_path)
+                    lca_sha1s = [get_sha1(tree, lca_path) for tree, lca_path
+                                 in zip(self._lca_trees, lca_paths)]
+                    this_sha1 = get_sha1(self.this_tree, this_path)
+                    other_sha1 = get_sha1(self.other_tree, other_path)
                     sha1_winner = self._lca_multi_way(
                         (base_sha1, lca_sha1s), other_sha1, this_sha1,
                         allow_overriding_lca=False)
@@ -1023,16 +1026,15 @@
                     if sha1_winner == 'this':
                         content_changed = False
                 elif other_ie.kind == 'symlink':
-                    def get_target(ie, tree):
+                    def get_target(ie, tree, path):
                         if ie.kind != 'symlink':
                             return None
-                        path = tree.id2path(file_id)
                         return tree.get_symlink_target(path, file_id)
-                    base_target = get_target(base_ie, self.base_tree)
-                    lca_targets = [get_target(ie, tree) for ie, tree
-                                   in zip(lca_entries, self._lca_trees)]
-                    this_target = get_target(this_ie, self.this_tree)
-                    other_target = get_target(other_ie, self.other_tree)
+                    base_target = get_target(base_ie, self.base_tree, base_path)
+                    lca_targets = [get_target(ie, tree, lca_path) for ie, tree, lca_path
+                                   in zip(lca_entries, self._lca_trees, lca_paths)]
+                    this_target = get_target(this_ie, self.this_tree, this_path)
+                    other_target = get_target(other_ie, self.other_tree, other_path)
                     target_winner = self._lca_multi_way(
                         (base_target, lca_targets),
                         other_target, this_target)
@@ -1056,6 +1058,8 @@
 
             # If we have gotten this far, that means something has changed
             result.append((file_id, content_changed,
+                           ((base_path, lca_paths),
+                            other_path, this_path),
                            ((base_ie.parent_id, lca_parent_ids),
                             other_ie.parent_id, this_ie.parent_id),
                            ((base_ie.name, lca_names),
@@ -1066,6 +1070,8 @@
         return result
 
     def write_modified(self, results):
+        if not self.working_tree.supports_merge_modified():
+            return
         modified_hashes = {}
         for path in results.modified_paths:
             wt_relpath = self.working_tree.relpath(path)
@@ -1076,10 +1082,7 @@
             if hash is None:
                 continue
             modified_hashes[file_id] = hash
-        try:
-            self.working_tree.set_merge_modified(modified_hashes)
-        except errors.UnsupportedOperation:
-            pass  # Well, whatever.
+        self.working_tree.set_merge_modified(modified_hashes)
 
     @staticmethod
     def parent(entry, file_id):
@@ -1096,33 +1099,30 @@
         return entry.name
 
     @staticmethod
-    def contents_sha1(tree, file_id):
+    def contents_sha1(tree, path, file_id=None):
         """Determine the sha1 of the file contents (used as a key method)."""
         try:
-            path = tree.id2path(file_id)
-        except errors.NoSuchId:
+            return tree.get_file_sha1(path, file_id)
+        except errors.NoSuchFile:
             return None
-        return tree.get_file_sha1(path, file_id)
 
     @staticmethod
-    def executable(tree, file_id):
+    def executable(tree, path, file_id=None):
         """Determine the executability of a file-id (used as a key method)."""
         try:
-            path = tree.id2path(file_id)
-        except errors.NoSuchId:
+            if tree.kind(path, file_id) != "file":
+                return False
+        except errors.NoSuchFile:
             return None
-        if tree.kind(path, file_id) != "file":
-            return False
         return tree.is_executable(path, file_id)
 
     @staticmethod
-    def kind(tree, path, file_id):
+    def kind(tree, path, file_id=None):
         """Determine the kind of a file-id (used as a key method)."""
         try:
-            path = tree.id2path(file_id)
-        except errors.NoSuchId:
+            return tree.kind(path, file_id)
+        except errors.NoSuchFile:
             return None
-        return tree.kind(path, file_id)
 
     @staticmethod
     def _three_way(base, other, this):
@@ -1209,13 +1209,14 @@
             else:
                 names.append(entry.name)
                 parents.append(entry.parent_id)
-        return self._merge_names(file_id, parents, names,
+        return self._merge_names(file_id, paths, parents, names,
                                  resolver=self._three_way)
 
-    def _merge_names(self, file_id, parents, names, resolver):
+    def _merge_names(self, file_id, paths, parents, names, resolver):
         """Perform a merge on file_id names and parents"""
         base_name, other_name, this_name = names
         base_parent, other_parent, this_parent = parents
+        unused_base_path, other_path, this_path = paths
 
         name_winner = resolver(*names)
 
@@ -1235,7 +1236,7 @@
             self._raw_conflicts.append(('path conflict', trans_id, file_id,
                                         this_parent, this_name,
                                         other_parent, other_name))
-        if not self.other_tree.has_id(file_id):
+        if other_path is None:
             # it doesn't matter whether the result was 'other' or
             # 'conflict'-- if it has no file id, we leave it alone.
             return
@@ -1257,12 +1258,10 @@
             self.tt.adjust_path(name, parent_trans_id,
                                 self.tt.trans_id_file_id(file_id))
 
-    def _do_merge_contents(self, file_id):
+    def _do_merge_contents(self, paths, file_id):
         """Performs a merge on file_id contents."""
-        def contents_pair(tree):
-            try:
-                path = tree.id2path(file_id)
-            except errors.NoSuchId:
+        def contents_pair(tree, path):
+            if path is None:
                 return (None, None)
             try:
                 kind = tree.kind(path, file_id)
@@ -1276,23 +1275,27 @@
                 contents = None
             return kind, contents
 
+        base_path, other_path, this_path = paths
         # See SPOT run.  run, SPOT, run.
         # So we're not QUITE repeating ourselves; we do tricky things with
         # file kind...
-        base_pair = contents_pair(self.base_tree)
-        other_pair = contents_pair(self.other_tree)
+        other_pair = contents_pair(self.other_tree, other_path)
+        this_pair = contents_pair(self.this_tree, this_path)
         if self._lca_trees:
-            this_pair = contents_pair(self.this_tree)
-            lca_pairs = [contents_pair(tree) for tree in self._lca_trees]
+            (base_path, lca_paths) = base_path
+            base_pair = contents_pair(self.base_tree, base_path)
+            lca_pairs = [contents_pair(tree, path)
+                         for tree, path in zip(self._lca_trees, lca_paths)]
             winner = self._lca_multi_way((base_pair, lca_pairs), other_pair,
                                          this_pair, allow_overriding_lca=False)
         else:
+            base_pair = contents_pair(self.base_tree, base_path)
             if base_pair == other_pair:
                 winner = 'this'
             else:
                 # We delayed evaluating this_pair as long as we can to avoid
                 # unnecessary sha1 calculation
-                this_pair = contents_pair(self.this_tree)
+                this_pair = contents_pair(self.this_tree, this_path)
                 winner = self._three_way(base_pair, other_pair, this_pair)
         if winner == 'this':
             # No interesting changes introduced by OTHER
@@ -1300,7 +1303,9 @@
         # We have a hypothetical conflict, but if we have files, then we
         # can try to merge the content
         trans_id = self.tt.trans_id_file_id(file_id)
-        params = MergeFileHookParams(self, file_id, trans_id, this_pair[0],
+        params = MergeFileHookParams(
+            self, file_id, (base_path, other_path,
+            this_path), trans_id, this_pair[0],
             other_pair[0], winner)
         hooks = self.active_hooks
         hook_status = 'not_applicable'
@@ -1324,9 +1329,7 @@
             inhibit_content_conflict = False
             if params.this_kind is None: # file_id is not in THIS
                 # Is the name used for a different file_id ?
-                dupe_path = self.other_tree.id2path(file_id)
-                this_id = self.this_tree.path2id(dupe_path)
-                if this_id is not None:
+                if self.this_tree.is_versioned(other_path):
                     # Two entries for the same path
                     keep_this = True
                     # versioning the merged file will trigger a duplicate
@@ -1334,14 +1337,12 @@
                     self.tt.version_file(file_id, trans_id)
                     transform.create_from_tree(
                         self.tt, trans_id, self.other_tree,
-                        self.other_tree.id2path(file_id), file_id=file_id,
+                        other_path, file_id=file_id,
                         filter_tree_path=self._get_filter_tree_path(file_id))
                     inhibit_content_conflict = True
             elif params.other_kind is None: # file_id is not in OTHER
                 # Is the name used for a different file_id ?
-                dupe_path = self.this_tree.id2path(file_id)
-                other_id = self.other_tree.path2id(dupe_path)
-                if other_id is not None:
+                if self.other_tree.is_versioned(this_path):
                     # Two entries for the same path again, but here, the other
                     # entry will also be merged.  We simply inhibit the
                     # 'content' conflict creation because we know OTHER will
@@ -1355,7 +1356,7 @@
                     self.tt.unversion_file(trans_id)
                 # This is a contents conflict, because none of the available
                 # functions could merge it.
-                file_group = self._dump_conflicts(name, parent_id, file_id,
+                file_group = self._dump_conflicts(name, paths, parent_id, file_id,
                                                   set_version=True)
                 self._raw_conflicts.append(('contents conflict', file_group))
         elif hook_status == 'success':
@@ -1367,7 +1368,7 @@
             self._raw_conflicts.append(('text conflict', trans_id))
             name = self.tt.final_name(trans_id)
             parent_id = self.tt.final_parent(trans_id)
-            self._dump_conflicts(name, parent_id, file_id)
+            self._dump_conflicts(name, paths, parent_id, file_id)
         elif hook_status == 'delete':
             self.tt.unversion_file(trans_id)
             result = "deleted"
@@ -1377,7 +1378,7 @@
             pass
         else:
             raise AssertionError('unknown hook_status: %r' % (hook_status,))
-        if not self.this_tree.has_id(file_id) and result == "modified":
+        if not this_path and result == "modified":
             self.tt.version_file(file_id, trans_id)
         if not keep_this:
             # The merge has been performed and produced a new content, so the
@@ -1389,14 +1390,14 @@
         """Replace this contents with other."""
         file_id = merge_hook_params.file_id
         trans_id = merge_hook_params.trans_id
-        if self.other_tree.has_id(file_id):
+        if merge_hook_params.other_path is not None:
             # OTHER changed the file
             transform.create_from_tree(
                 self.tt, trans_id, self.other_tree,
-                self.other_tree.id2path(file_id), file_id=file_id,
+                merge_hook_params.other_path, file_id=file_id,
                 filter_tree_path=self._get_filter_tree_path(file_id))
             return 'done', None
-        elif self.this_tree.has_id(file_id):
+        elif merge_hook_params.this_path is not None:
             # OTHER deleted the file
             return 'delete', None
         else:
@@ -1417,38 +1418,35 @@
             # BASE is a file, or both converted to files, so at least we
             # have agreement that output should be a file.
             try:
-                self.text_merge(merge_hook_params.file_id,
-                    merge_hook_params.trans_id)
+                self.text_merge(merge_hook_params.trans_id,
+                                merge_hook_params.paths, merge_hook_params.file_id)
             except errors.BinaryFile:
                 return 'not_applicable', None
             return 'done', None
         else:
             return 'not_applicable', None
 
-    def get_lines(self, tree, file_id):
+    def get_lines(self, tree, path, file_id=None):
         """Return the lines in a file, or an empty list."""
+        if path is None:
+            return []
         try:
-            path = tree.id2path(file_id)
-        except errors.NoSuchId:
+            kind = tree.kind(path, file_id)
+        except errors.NoSuchFile:
             return []
         else:
+            if kind != 'file':
+                return []
             return tree.get_file_lines(path, file_id)
 
-    def text_merge(self, file_id, trans_id):
+    def text_merge(self, trans_id, paths, file_id):
         """Perform a three-way text merge on a file_id"""
         # it's possible that we got here with base as a different type.
         # if so, we just want two-way text conflicts.
-        try:
-            base_path = self.base_tree.id2path(file_id)
-        except errors.NoSuchId:
-            base_lines = []
-        else:
-            if self.base_tree.kind(base_path, file_id) == "file":
-                base_lines = self.get_lines(self.base_tree, file_id)
-            else:
-                base_lines = []
-        other_lines = self.get_lines(self.other_tree, file_id)
-        this_lines = self.get_lines(self.this_tree, file_id)
+        base_path, other_path, this_path = paths
+        base_lines = self.get_lines(self.base_tree, base_path, file_id)
+        other_lines = self.get_lines(self.other_tree, other_path, file_id)
+        this_lines = self.get_lines(self.this_tree, this_path, file_id)
         m3 = merge3.Merge3(base_lines, this_lines, other_lines,
                            is_cherrypick=self.cherrypick)
         start_marker = "!START OF MERGE CONFLICT!" + "I HOPE THIS IS UNIQUE"
@@ -1477,7 +1475,7 @@
             self._raw_conflicts.append(('text conflict', trans_id))
             name = self.tt.final_name(trans_id)
             parent_id = self.tt.final_parent(trans_id)
-            file_group = self._dump_conflicts(name, parent_id, file_id,
+            file_group = self._dump_conflicts(name, paths, parent_id, file_id,
                                               this_lines, base_lines,
                                               other_lines)
             file_group.append(trans_id)
@@ -1495,7 +1493,7 @@
         # Skip the id2path lookup for older formats
         return None
 
-    def _dump_conflicts(self, name, parent_id, file_id, this_lines=None,
+    def _dump_conflicts(self, name, paths, parent_id, file_id, this_lines=None,
                         base_lines=None, other_lines=None, set_version=False,
                         no_base=False):
         """Emit conflict files.
@@ -1503,10 +1501,11 @@
         determined automatically.  If set_version is true, the .OTHER, .THIS
         or .BASE (in that order) will be created as versioned files.
         """
-        data = [('OTHER', self.other_tree, other_lines),
-                ('THIS', self.this_tree, this_lines)]
+        base_path, other_path, this_path = paths
+        data = [('OTHER', self.other_tree, other_path, other_lines),
+                ('THIS', self.this_tree, this_path, this_lines)]
         if not no_base:
-            data.append(('BASE', self.base_tree, base_lines))
+            data.append(('BASE', self.base_tree, base_path, base_lines))
 
         # We need to use the actual path in the working tree of the file here,
         # ignoring the conflict suffixes
@@ -1523,12 +1522,8 @@
 
         versioned = False
         file_group = []
-        for suffix, tree, lines in data:
-            try:
-                path = tree.id2path(file_id)
-            except errors.NoSuchId:
-                pass
-            else:
+        for suffix, tree, path, lines in data:
+            if path is not None:
                 trans_id = self._conflict_file(
                         name, parent_id, path, tree, file_id, suffix, lines,
                         filter_tree_path)
@@ -1549,24 +1544,25 @@
                 filter_tree_path=filter_tree_path)
         return trans_id
 
-    def merge_executable(self, file_id, file_status):
+    def merge_executable(self, paths, file_id, file_status):
         """Perform a merge on the execute bit."""
-        executable = [self.executable(t, file_id) for t in (self.base_tree,
-                      self.other_tree, self.this_tree)]
-        self._merge_executable(file_id, executable, file_status,
+        executable = [self.executable(t, p, file_id) for t, p in zip([self.base_tree,
+                      self.other_tree, self.this_tree], paths)]
+        self._merge_executable(paths, file_id, executable, file_status,
                                resolver=self._three_way)
 
-    def _merge_executable(self, file_id, executable, file_status,
+    def _merge_executable(self, paths, file_id, executable, file_status,
                           resolver):
         """Perform a merge on the execute bit."""
         base_executable, other_executable, this_executable = executable
+        base_path, other_path, this_path = paths
         if file_status == "deleted":
             return
         winner = resolver(*executable)
         if winner == "conflict":
         # There must be a None in here, if we have a conflict, but we
         # need executability since file status was not deleted.
-            if self.executable(self.other_tree, file_id) is None:
+            if self.executable(self.other_tree, other_path, file_id) is None:
                 winner = "this"
             else:
                 winner = "other"
@@ -1578,11 +1574,11 @@
         if winner == "this":
             executability = this_executable
         else:
-            if self.other_tree.has_id(file_id):
+            if other_path is not None:
                 executability = other_executable
-            elif self.this_tree.has_id(file_id):
+            elif this_path is not None:
                 executability = this_executable
-            elif self.base_tree_has_id(file_id):
+            elif base_path is not None:
                 executability = base_executable
         if executability is not None:
             trans_id = self.tt.trans_id_file_id(file_id)
@@ -1696,11 +1692,12 @@
             base_lines = None
         return lines, base_lines
 
-    def text_merge(self, file_id, trans_id):
+    def text_merge(self, trans_id, paths, file_id):
         """Perform a (weave) text merge for a given file and file-id.
         If conflicts are encountered, .THIS and .OTHER files will be emitted,
         and a conflict will be noted.
         """
+        base_path, other_path, this_path = paths
         lines, base_lines = self._merged_lines(file_id)
         lines = list(lines)
         # Note we're checking whether the OUTPUT is binary in this case,
@@ -1712,7 +1709,7 @@
             self._raw_conflicts.append(('text conflict', trans_id))
             name = self.tt.final_name(trans_id)
             parent_id = self.tt.final_parent(trans_id)
-            file_group = self._dump_conflicts(name, parent_id, file_id,
+            file_group = self._dump_conflicts(name, paths, parent_id, file_id,
                                               no_base=False,
                                               base_lines=base_lines)
             file_group.append(trans_id)
@@ -1731,26 +1728,27 @@
 
     requires_file_merge_plan = False
 
-    def dump_file(self, temp_dir, name, tree, file_id):
+    def dump_file(self, temp_dir, name, tree, path, file_id=None):
         out_path = osutils.pathjoin(temp_dir, name)
         with open(out_path, "wb") as out_file:
-            in_file = tree.get_file(tree.id2path(file_id), file_id)
+            in_file = tree.get_file(path, file_id=None)
             for line in in_file:
                 out_file.write(line)
         return out_path
 
-    def text_merge(self, file_id, trans_id):
+    def text_merge(self, trans_id, paths, file_id):
         """Perform a diff3 merge using a specified file-id and trans-id.
         If conflicts are encountered, .BASE, .THIS. and .OTHER conflict files
         will be dumped, and a will be conflict noted.
         """
         import breezy.patch
+        base_path, other_path, this_path = paths
         temp_dir = osutils.mkdtemp(prefix="bzr-")
         try:
             new_file = osutils.pathjoin(temp_dir, "new")
-            this = self.dump_file(temp_dir, "this", self.this_tree, file_id)
-            base = self.dump_file(temp_dir, "base", self.base_tree, file_id)
-            other = self.dump_file(temp_dir, "other", self.other_tree, file_id)
+            this = self.dump_file(temp_dir, "this", self.this_tree, this_path, file_id)
+            base = self.dump_file(temp_dir, "base", self.base_tree, base_path, file_id)
+            other = self.dump_file(temp_dir, "other", self.other_tree, other_path, file_id)
             status = breezy.patch.diff3(new_file, this, base, other)
             if status not in (0, 1):
                 raise errors.BzrError("Unhandled diff3 exit code")
@@ -1759,7 +1757,7 @@
             if status == 1:
                 name = self.tt.final_name(trans_id)
                 parent_id = self.tt.final_parent(trans_id)
-                self._dump_conflicts(name, parent_id, file_id)
+                self._dump_conflicts(name, paths, parent_id, file_id)
                 self._raw_conflicts.append(('text conflict', trans_id))
         finally:
             osutils.rmtree(temp_dir)
@@ -1816,7 +1814,7 @@
         self.merge_type = Merge3Merger
         self.show_base = False
         self.reprocess = False
-        self.interesting_ids = None
+        self.interesting_files = None
         self.merge_type = _MergeTypeParameterizer(MergeIntoMergeType,
               target_subdir=self._target_subdir,
               source_subpath=self._source_subpath)
@@ -1878,11 +1876,16 @@
         with ui.ui_factory.nested_progress_bar() as child_pb:
             entries = self._entries_to_incorporate()
             entries = list(entries)
-            for num, (entry, parent_id, path) in enumerate(entries):
+            for num, (entry, parent_id, relpath) in enumerate(entries):
                 child_pb.update(gettext('Preparing file merge'), num, len(entries))
                 parent_trans_id = self.tt.trans_id_file_id(parent_id)
+<<<<<<< TREE
                 trans_id = transform.new_by_entry(
                     self.other_tree.id2path(entry.file_id), self.tt, entry,
+=======
+                path = osutils.pathjoin(self._source_subpath, relpath)
+                trans_id = transform.new_by_entry(path, self.tt, entry,
+>>>>>>> MERGE-SOURCE
                     parent_trans_id, self.other_tree)
         self._finish_computing_transform()
 
@@ -1928,7 +1931,6 @@
 def merge_inner(this_branch, other_tree, base_tree, ignore_zero=False,
                 backup_files=False,
                 merge_type=Merge3Merger,
-                interesting_ids=None,
                 show_base=False,
                 reprocess=False,
                 other_rev_id=None,
@@ -1949,13 +1951,8 @@
                     change_reporter=change_reporter)
     merger.backup_files = backup_files
     merger.merge_type = merge_type
-    merger.interesting_ids = interesting_ids
     merger.ignore_zero = ignore_zero
-    if interesting_files:
-        if interesting_ids:
-            raise ValueError('Only supply interesting_ids'
-                             ' or interesting_files')
-        merger.interesting_files = interesting_files
+    merger.interesting_files = interesting_files
     merger.show_base = show_base
     merger.reprocess = reprocess
     merger.other_rev_id = other_rev_id

=== modified file 'breezy/plugins/changelog_merge/changelog_merge.py'
--- breezy/plugins/changelog_merge/changelog_merge.py	2018-03-09 19:28:43 +0000
+++ breezy/plugins/changelog_merge/changelog_merge.py	2018-03-24 17:11:56 +0000
@@ -23,6 +23,7 @@
 from ... import (
     debug,
     merge,
+    osutils,
     urlutils,
     )
 from ...merge3 import Merge3
@@ -63,6 +64,7 @@
 
     name_prefix = "changelog"
 
+<<<<<<< TREE
     def get_filepath(self, params, tree):
         """Calculate the path to the file in a tree.
 
@@ -75,6 +77,27 @@
         :param tree: a Tree, e.g. self.merger.this_tree.
         """
         return self.get_filename(params, tree)
+=======
+    def file_matches(self, params):
+        affected_files = self.affected_files
+        if affected_files is None:
+            config = self.merger.this_branch.get_config()
+            # Until bzr provides a better policy for caching the config, we
+            # just add the part we're interested in to the params to avoid
+            # reading the config files repeatedly (breezy.conf, location.conf,
+            # branch.conf).
+            config_key = self.name_prefix + '_merge_files'
+            affected_files = config.get_user_option_as_list(config_key)
+            if affected_files is None:
+                # If nothing was specified in the config, use the default.
+                affected_files = self.default_files
+            self.affected_files = affected_files
+        if affected_files:
+            filepath = osutils.basename(params.this_path)
+            if filepath in affected_files:
+                return True
+        return False
+>>>>>>> MERGE-SOURCE
 
     def merge_text(self, params):
         """Merge changelog changes.

=== modified file 'breezy/plugins/changelog_merge/tests/test_changelog_merge.py'
--- breezy/plugins/changelog_merge/tests/test_changelog_merge.py	2017-05-21 18:10:28 +0000
+++ breezy/plugins/changelog_merge/tests/test_changelog_merge.py	2018-03-24 17:11:56 +0000
@@ -191,8 +191,9 @@
         # won't write the new value to disk where get_user_option can get it).
         merger.this_branch.get_config().set_user_option(
             'changelog_merge_files', 'ChangeLog')
-        merge_hook_params = merge.MergeFileHookParams(merger, 'clog-id', None,
-            'file', 'file', 'conflict')
+        merge_hook_params = merge.MergeFileHookParams(merger, 'clog-id',
+                ['ChangeLog', 'ChangeLog', 'ChangeLog'], None,
+                'file', 'file', 'conflict')
         changelog_merger = changelog_merge.ChangeLogMerger(merger)
         return changelog_merger, merge_hook_params
 

=== modified file 'breezy/plugins/launchpad/lp_registration.py'
--- breezy/plugins/launchpad/lp_registration.py	2017-09-26 00:55:04 +0000
+++ breezy/plugins/launchpad/lp_registration.py	2018-03-24 17:11:56 +0000
@@ -74,8 +74,7 @@
         self.verbose = verbose
         url = self._scheme + "://" + host + handler
         request = _urllib2_wrappers.Request("POST", url, request_body)
-        # FIXME: _urllib2_wrappers will override user-agent with its own
-        # request.add_header("User-Agent", self.user_agent)
+        request.add_header("User-Agent", self.user_agent)
         request.add_header("Content-Type", "text/xml")
 
         response = self._opener.open(request)
@@ -122,7 +121,7 @@
         if transport is None:
             uri_type = urllib.splittype(self.service_url)[0]
             transport = XMLRPCTransport(uri_type)
-            transport.user_agent = 'bzr/%s (xmlrpclib/%s)' \
+            transport.user_agent = 'Breezy/%s (xmlrpclib/%s)' \
                     % (_breezy_version, xmlrpclib.__version__)
         self.transport = transport
 

=== modified file 'breezy/plugins/po_merge/po_merge.py'
--- breezy/plugins/po_merge/po_merge.py	2017-05-22 00:56:52 +0000
+++ breezy/plugins/po_merge/po_merge.py	2018-03-24 17:11:56 +0000
@@ -99,7 +99,7 @@
             # Return early if there is no options defined
             return False
         po_dir = None
-        po_path = self.get_filepath(params, self.merger.this_tree)
+        po_path = params.this_path
         for po_dir in self.po_dirs:
             glob = osutils.pathjoin(po_dir, self.po_glob)
             if fnmatch.fnmatch(po_path, glob):

=== modified file 'breezy/plugins/stats/cmds.py'
--- breezy/plugins/stats/cmds.py	2018-02-24 15:50:23 +0000
+++ breezy/plugins/stats/cmds.py	2018-03-24 17:11:56 +0000
@@ -145,7 +145,7 @@
     combo_count = {}
     with ui.ui_factory.nested_progress_bar() as pb:
         trace.note('getting revisions')
-        revisions = a_repo.iter_revisions(revids)
+        revisions = list(a_repo.iter_revisions(revids))
         for count, (revid, rev) in enumerate(revisions):
             pb.update('checking', count, len(revids))
             for author in rev.get_apparent_authors():
@@ -155,7 +155,8 @@
                 email_users.setdefault(email, set()).add(username)
                 combo = (username, email)
                 combo_count[combo] = combo_count.setdefault(combo, 0) + 1
-    return revisions, collapse_email_and_users(email_users, combo_count)
+    return ((rev for (revid, rev) in revisions),
+            collapse_email_and_users(email_users, combo_count))
 
 
 def get_info(a_repo, revision):

=== modified file 'breezy/plugins/stats/test_stats.py'
--- breezy/plugins/stats/test_stats.py	2017-06-01 23:52:12 +0000
+++ breezy/plugins/stats/test_stats.py	2018-03-24 17:11:56 +0000
@@ -45,6 +45,7 @@
         self.assertEqual({('Fero', ''): ('Fero', ''),
                           ('FERO', ''): ('Fero', ''),
                          }, committers)
+        self.assertEquals(['1', '2', '3'], sorted([r.revision_id for r in revs]))
 
 
 class TestCollapseByPerson(TestCase):

=== modified file 'breezy/rename_map.py'
--- breezy/rename_map.py	2018-03-12 05:18:13 +0000
+++ breezy/rename_map.py	2018-03-24 17:11:56 +0000
@@ -26,6 +26,7 @@
 from .sixish import (
     BytesIO,
     viewitems,
+    viewvalues,
     )
 from .ui import ui_factory
 
@@ -237,7 +238,14 @@
     def _make_inventory_delta(self, matches):
         delta = []
         file_id_matches = dict((f, p) for p, f in viewitems(matches))
-        for old_path, entry in self.tree.iter_entries_by_dir(file_id_matches):
+        file_id_query = []
+        for f in viewvalues(matches):
+            try:
+                file_id_query.append(self.tree.id2path(f))
+            except errors.NoSuchId:
+                pass
+        for old_path, entry in self.tree.iter_entries_by_dir(
+                specific_files=file_id_query):
             new_path = file_id_matches[entry.file_id]
             parent_path, new_name = osutils.split(new_path)
             parent_id = matches.get(parent_path)

=== modified file 'breezy/tests/__init__.py'
--- breezy/tests/__init__.py	2018-02-15 19:38:33 +0000
+++ breezy/tests/__init__.py	2018-03-24 17:11:56 +0000
@@ -2693,7 +2693,7 @@
     def make_branch_and_memory_tree(self, relpath, format=None):
         """Create a branch on the default transport and a MemoryTree for it."""
         b = self.make_branch(relpath, format=format)
-        return memorytree.MemoryTree.create_on_branch(b)
+        return b.create_memorytree()
 
     def make_branch_builder(self, relpath, format=None):
         branch = self.make_branch(relpath, format=format)

=== modified file 'breezy/tests/blackbox/test_config.py'
--- breezy/tests/blackbox/test_config.py	2017-07-30 18:38:48 +0000
+++ breezy/tests/blackbox/test_config.py	2018-03-24 17:11:56 +0000
@@ -116,20 +116,20 @@
             ''')
 
     def test_registry_value_all(self):
-        self.breezy_config.set_user_option('bzr.transform.orphan_policy',
+        self.breezy_config.set_user_option('transform.orphan_policy',
                                            u'move')
         script.run_script(self, '''\
             $ brz config -d tree
             breezy:
               [DEFAULT]
-              bzr.transform.orphan_policy = move
+              transform.orphan_policy = move
             ''')
 
     def test_registry_value_one(self):
-        self.breezy_config.set_user_option('bzr.transform.orphan_policy',
+        self.breezy_config.set_user_option('transform.orphan_policy',
                                            u'move')
         script.run_script(self, '''\
-            $ brz config -d tree bzr.transform.orphan_policy
+            $ brz config -d tree transform.orphan_policy
             move
             ''')
 

=== modified file 'breezy/tests/matchers.py'
--- breezy/tests/matchers.py	2018-03-12 02:33:32 +0000
+++ breezy/tests/matchers.py	2018-03-24 17:11:56 +0000
@@ -184,6 +184,7 @@
         return Equals(entries).match(actual)
 
 
+<<<<<<< TREE
 class HasPathRelations(Matcher):
     """Matcher verifies that paths have a relation to those in another tree.
 
@@ -241,6 +242,79 @@
         return Equals(entries).match(actual)
 
 
+=======
+class HasPathRelations(Matcher):
+    """Matcher verifies that paths have a relation to those in another tree.
+
+    :ivar previous_tree: tree to compare to
+    :ivar previous_entries: List of expected entries, as (path, previous_path) pairs.
+    """
+
+    def __init__(self, previous_tree, previous_entries):
+        Matcher.__init__(self)
+        self.previous_tree = previous_tree
+        self.previous_entries = previous_entries
+
+    def get_path_map(self, tree):
+        """Get the (path, previous_path) pairs for the current tree."""
+        with tree.lock_read(), self.previous_tree.lock_read():
+            for path, ie in tree.iter_entries_by_dir():
+                if tree.supports_rename_tracking():
+                    previous_path = find_previous_path(tree, self.previous_tree, path)
+                else:
+                    if self.previous_tree.is_versioned(path):
+                        previous_path = path
+                    else:
+                        previous_path = None
+                if previous_path:
+                    kind = self.previous_tree.kind(previous_path)
+                    if kind == 'directory':
+                        previous_path += '/'
+                if ie.parent_id is None:
+                    yield (u"", previous_path)
+                else:
+                    yield (path+ie.kind_character(), previous_path)
+
+    @staticmethod
+    def _strip_unreferenced_directories(entries):
+        """Strip all directories that don't (in)directly contain any files.
+
+        :param entries: List of path strings or (path, previous_path) tuples to process
+        """
+        directories = []
+        for entry in entries:
+            if isinstance(entry, (str, text_type)):
+                path = entry
+            else:
+                path = entry[0]
+            if not path or path[-1] == "/":
+                # directory
+                directories.append((path, entry))
+            else:
+                # Yield the referenced parent directories
+                for dirpath, direntry in directories:
+                    if osutils.is_inside(dirpath, path):
+                        yield direntry
+                directories = []
+                yield entry
+
+    def __str__(self):
+        return 'HasPathRelations(%r, %r)' % (self.previous_tree, self.previous_entries)
+
+    def match(self, tree):
+        actual = list(self.get_path_map(tree))
+        if not tree.has_versioned_directories():
+            entries = list(self._strip_unreferenced_directories(self.previous_entries))
+        else:
+            entries = self.previous_entries
+        if not tree.supports_rename_tracking():
+            entries = [
+                (path, path if self.previous_tree.is_versioned(path) else None)
+                for (path, previous_path) in entries]
+        return Equals(entries).match(actual)
+
+
+>>>>>>> MERGE-SOURCE
 class RevisionHistoryMatches(Matcher):
     """A matcher that checks if a branch has a specific revision history.
 

=== modified file 'breezy/tests/per_branch/test_branch.py'
--- breezy/tests/per_branch/test_branch.py	2018-03-07 01:11:19 +0000
+++ breezy/tests/per_branch/test_branch.py	2018-03-24 17:11:56 +0000
@@ -34,6 +34,7 @@
     revision,
     shelf,
     tests,
+    tree as _mod_tree,
     )
 from breezy.bzr import (
     branch as _mod_bzrbranch,
@@ -497,6 +498,10 @@
         self.assertFalse(revision.NULL_REVISION in must_fetch)
         self.assertFalse(revision.NULL_REVISION in should_fetch)
 
+    def test_create_memorytree(self):
+        tree = self.make_branch_and_tree('a')
+        self.assertIsInstance(tree.branch.create_memorytree(), _mod_tree.Tree)
+
 
 class TestBranchFormat(per_branch.TestCaseWithBranch):
 

=== modified file 'breezy/tests/per_branch/test_commit.py'
--- breezy/tests/per_branch/test_commit.py	2018-01-12 08:52:43 +0000
+++ breezy/tests/per_branch/test_commit.py	2018-03-24 17:11:56 +0000
@@ -194,7 +194,8 @@
             dir_id = tree.path2id('dir')
             tree.add('dir/subfile')
             dir_subfile_id = tree.path2id('dir/subfile')
-            tree.mkdir('to_be_unversioned')
+            tree.put_file_bytes_non_atomic('to_be_unversioned', 'blah')
+            tree.add(['to_be_unversioned'])
             to_be_unversioned_id = tree.path2id('to_be_unversioned')
             tree.put_file_bytes_non_atomic('dir/subfile', 'def')
             revid1 = tree.commit('first revision')
@@ -212,11 +213,19 @@
             revid2 = tree.commit('second revision')
 
         expected_delta = delta.TreeDelta()
-        expected_delta.added = [('added_dir', added_dir_id, 'directory')]
-        expected_delta.removed = [('to_be_unversioned',
-                                   to_be_unversioned_id, 'directory')]
-        expected_delta.renamed = [('dir/subfile', 'dir/subfile_renamed',
-                                   dir_subfile_id, 'file', False, False)]
+        if tree.has_versioned_directories():
+            expected_delta.added.append(('added_dir', added_dir_id, 'directory'))
+        if tree.supports_rename_tracking():
+            expected_delta.removed = [('to_be_unversioned',
+                                       to_be_unversioned_id, 'file')]
+            expected_delta.renamed = [('dir/subfile', 'dir/subfile_renamed',
+                                       dir_subfile_id, 'file', False, False)]
+        else:
+            expected_delta.added.append(('dir/subfile_renamed',
+                                        tree.path2id('dir/subfile_renamed'), 'file'))
+            expected_delta.removed = [
+                    ('dir/subfile', dir_subfile_id, 'file'),
+                    ('to_be_unversioned', to_be_unversioned_id, 'file')]
         expected_delta.modified=[('rootfile', rootfile_id, 'file', True,
                                   False)]
         self.assertEqual([('pre_commit', 1, revid1, 2, revid2,

=== modified file 'breezy/tests/per_controldir/test_controldir.py'
=== modified file 'breezy/tests/per_controldir_colo/test_supported.py'
=== modified file 'breezy/tests/per_intertree/test_compare.py'
--- breezy/tests/per_intertree/test_compare.py	2017-11-21 20:37:41 +0000
+++ breezy/tests/per_intertree/test_compare.py	2018-03-24 17:11:56 +0000
@@ -557,7 +557,9 @@
 
     @staticmethod
     def get_path_entry(tree, file_id):
-        iterator = tree.iter_entries_by_dir(specific_file_ids=[file_id])
+        with tree.lock_read():
+            path = tree.id2path(file_id)
+        iterator = tree.iter_entries_by_dir(specific_files=[path])
         try:
             return next(iterator)
         except StopIteration:

=== modified file 'breezy/tests/per_intertree/test_file_content_matches.py'
--- breezy/tests/per_intertree/test_file_content_matches.py	2018-03-09 18:27:46 +0000
+++ breezy/tests/per_intertree/test_file_content_matches.py	2018-03-24 17:11:56 +0000
@@ -32,7 +32,13 @@
         tree2.add('file', 'file-id-2')
         tree1, tree2 = self.mutable_trees_to_test_trees(self, tree1, tree2)
         inter = self.intertree_class(tree1, tree2)
-        self.assertTrue(inter.file_content_matches('file', 'file'))
+<<<<<<< TREE
+        self.assertTrue(inter.file_content_matches('file', 'file'))
+=======
+        self.assertTrue(inter.file_content_matches(
+            'file', 'file', 'file-id-1', 'file-id-2'))
+        self.assertTrue(inter.file_content_matches('file', 'file'))
+>>>>>>> MERGE-SOURCE
 
     def test_different_contents_and_same_verifier(self):
         tree1 = self.make_branch_and_tree('1')
@@ -45,4 +51,11 @@
         tree2.add('file', 'file-id-2')
         tree1, tree2 = self.mutable_trees_to_test_trees(self, tree1, tree2)
         inter = self.intertree_class(tree1, tree2)
+<<<<<<< TREE
         self.assertFalse(inter.file_content_matches('file', 'file'))
+=======
+        self.assertFalse(inter.file_content_matches(
+            'file', 'file', 'file-id-1', 'file-id-2'))
+        self.assertFalse(inter.file_content_matches(
+            'file', 'file'))
+>>>>>>> MERGE-SOURCE

=== modified file 'breezy/tests/per_repository/test_commit_builder.py'
--- breezy/tests/per_repository/test_commit_builder.py	2018-03-09 00:05:39 +0000
+++ breezy/tests/per_repository/test_commit_builder.py	2018-03-24 17:11:56 +0000
@@ -181,7 +181,7 @@
 
     def test_commit_unchanged_root_record_iter_changes(self):
         tree = self.make_branch_and_tree(".")
-        old_revision_id = tree.commit('')
+        old_revision_id = tree.commit('oldrev')
         tree.lock_write()
         builder = tree.branch.get_commit_builder([old_revision_id])
         try:
@@ -190,7 +190,7 @@
             # pointless commit.
             self.assertFalse(builder.any_changes())
             builder.finish_inventory()
-            builder.commit('')
+            builder.commit('rev')
             builder_tree = builder.revision_tree()
             new_root_id = builder_tree.get_root_id()
             new_root_revision = builder_tree.get_file_revision(u'')
@@ -284,8 +284,8 @@
         # commiting without changing the root does not change the
         # last modified except on non-rich-root-repositories.
         tree = self.make_branch_and_tree('.')
-        rev1 = tree.commit('')
-        rev2 = tree.commit('')
+        rev1 = tree.commit('rev1')
+        rev2 = tree.commit('rev2')
         tree1, tree2 = self._get_revtrees(tree, [rev1, rev2])
         self.assertEqual(rev1, tree1.get_file_revision(u''))
         if tree.branch.repository.supports_rich_root():
@@ -293,14 +293,13 @@
         else:
             self.assertEqual(rev2, tree2.get_file_revision(u''))
 
-    def _add_commit_check_unchanged(self, tree, name, mini_commit=None):
+    def _add_commit_check_unchanged(self, tree, name):
         tree.add([name])
-        self._commit_check_unchanged(tree, name, tree.path2id(name),
-            mini_commit=mini_commit)
+        self._commit_check_unchanged(tree, name, tree.path2id(name))
 
-    def _commit_check_unchanged(self, tree, name, file_id, mini_commit=None):
-        rev1 = tree.commit('')
-        rev2 = mini_commit(tree, name, name, False, False)
+    def _commit_check_unchanged(self, tree, name, file_id):
+        rev1 = tree.commit('rev1')
+        rev2 = self.mini_commit_record_iter_changes(tree, name, name, False, False)
         tree1, tree2 = self._get_revtrees(tree, [rev1, rev2])
         self.assertEqual(rev1, tree1.get_file_revision(tree1.id2path(file_id)))
         self.assertEqual(rev1, tree2.get_file_revision(tree2.id2path(file_id)))
@@ -315,8 +314,7 @@
             raise tests.TestNotApplicable(
                     'Format does not support versioned directories')
         self.build_tree(['dir/'])
-        self._add_commit_check_unchanged(tree, 'dir',
-            mini_commit=self.mini_commit_record_iter_changes)
+        self._add_commit_check_unchanged(tree, 'dir')
 
     def test_last_modified_revision_after_commit_dir_contents_unchanged(self):
         # committing without changing a dir does not change the last modified
@@ -325,10 +323,10 @@
         self.build_tree(['dir/', 'dir/orig'])
         tree.add(['dir', 'dir/orig'])
         dir_id = tree.path2id('dir')
-        rev1 = tree.commit('')
+        rev1 = tree.commit('rev1')
         self.build_tree(['dir/content'])
         tree.add(['dir/content'])
-        rev2 = tree.commit('')
+        rev2 = tree.commit('rev2')
         tree1, tree2 = self._get_revtrees(tree, [rev1, rev2])
         self.assertEqual(rev1, tree1.get_file_revision('dir'))
         self.assertEqual(rev1, tree2.get_file_revision('dir'))
@@ -339,16 +337,14 @@
         # committing without changing a file does not change the last modified.
         tree = self.make_branch_and_tree('.')
         self.build_tree(['file'])
-        self._add_commit_check_unchanged(tree, 'file',
-            mini_commit=self.mini_commit_record_iter_changes)
+        self._add_commit_check_unchanged(tree, 'file')
 
     def test_last_modified_revision_after_commit_link_unchanged(self):
         # committing without changing a link does not change the last modified.
         self.requireFeature(features.SymlinkFeature)
         tree = self.make_branch_and_tree('.')
         os.symlink('target', 'link')
-        self._add_commit_check_unchanged(tree, 'link',
-            mini_commit=self.mini_commit_record_iter_changes)
+        self._add_commit_check_unchanged(tree, 'link')
 
     def test_last_modified_revision_after_commit_reference_unchanged(self):
         # committing without changing a subtree does not change the last
@@ -358,47 +354,47 @@
         try:
             tree.add_reference(subtree)
             self._commit_check_unchanged(tree, 'reference',
-                subtree.get_root_id(),
-                mini_commit=self.mini_commit_record_iter_changes)
+                subtree.get_root_id())
         except errors.UnsupportedOperation:
             return
 
     def _add_commit_renamed_check_changed(self, tree, name,
-        expect_fs_hash=False, mini_commit=None):
+        expect_fs_hash=False):
         def rename():
             tree.rename_one(name, 'new_' + name)
-        self._add_commit_change_check_changed(tree, name, rename,
-            expect_fs_hash=expect_fs_hash, mini_commit=mini_commit)
+        self._add_commit_change_check_changed(tree,
+                (name, 'new_' + name), rename,
+            expect_fs_hash=expect_fs_hash)
 
-    def _commit_renamed_check_changed(self, tree, name, file_id,
-        expect_fs_hash=False, mini_commit=None):
+    def _commit_renamed_check_changed(self, tree, name,
+        expect_fs_hash=False):
         def rename():
             tree.rename_one(name, 'new_' + name)
-        self._commit_change_check_changed(tree, name, file_id, rename,
-            expect_fs_hash=expect_fs_hash, mini_commit=mini_commit)
+        self._commit_change_check_changed(tree, [name, 'new_' + name],
+                rename, expect_fs_hash=expect_fs_hash)
 
     def test_last_modified_revision_after_rename_dir_changes(self):
         # renaming a dir changes the last modified.
         tree = self.make_branch_and_tree('.')
+        if not tree.has_versioned_directories():
+            raise tests.TestNotApplicable(
+                    'Format does not support versioned directories')
         self.build_tree(['dir/'])
-        self._add_commit_renamed_check_changed(tree, 'dir',
-            mini_commit=self.mini_commit_record_iter_changes)
+        self._add_commit_renamed_check_changed(tree, 'dir')
 
     def test_last_modified_revision_after_rename_file_changes(self):
         # renaming a file changes the last modified.
         tree = self.make_branch_and_tree('.')
         self.build_tree(['file'])
         self._add_commit_renamed_check_changed(tree, 'file',
-            expect_fs_hash=True,
-            mini_commit=self.mini_commit_record_iter_changes)
+            expect_fs_hash=True)
 
     def test_last_modified_revision_after_rename_link_changes(self):
         # renaming a link changes the last modified.
         self.requireFeature(features.SymlinkFeature)
         tree = self.make_branch_and_tree('.')
         os.symlink('target', 'link')
-        self._add_commit_renamed_check_changed(tree, 'link',
-            mini_commit=self.mini_commit_record_iter_changes)
+        self._add_commit_renamed_check_changed(tree, 'link')
 
     def test_last_modified_revision_after_rename_ref_changes(self):
         # renaming a reference changes the last modified.
@@ -406,62 +402,58 @@
         subtree = self.make_reference('reference')
         try:
             tree.add_reference(subtree)
-            self._commit_renamed_check_changed(tree, 'reference',
-                subtree.get_root_id(),
-                mini_commit=self.mini_commit_record_iter_changes)
+            self._commit_renamed_check_changed(tree, 'reference')
         except errors.UnsupportedOperation:
             return
 
     def _add_commit_reparent_check_changed(self, tree, name,
-        expect_fs_hash=False, mini_commit=None):
+        expect_fs_hash=False):
         self.build_tree(['newparent/'])
         tree.add(['newparent'])
         def reparent():
             tree.rename_one(name, 'newparent/new_' + name)
-        self._add_commit_change_check_changed(tree, name, reparent,
-            expect_fs_hash=expect_fs_hash, mini_commit=mini_commit)
+        self._add_commit_change_check_changed(
+                tree, (name, 'newparent/new_' + name), reparent,
+            expect_fs_hash=expect_fs_hash)
 
     def test_last_modified_revision_after_reparent_dir_changes(self):
         # reparenting a dir changes the last modified.
         tree = self.make_branch_and_tree('.')
         self.build_tree(['dir/'])
-        self._add_commit_reparent_check_changed(tree, 'dir',
-            mini_commit=self.mini_commit_record_iter_changes)
+        self._add_commit_reparent_check_changed(tree, 'dir')
 
     def test_last_modified_revision_after_reparent_file_changes(self):
         # reparenting a file changes the last modified.
         tree = self.make_branch_and_tree('.')
         self.build_tree(['file'])
         self._add_commit_reparent_check_changed(tree, 'file',
-            expect_fs_hash=True,
-            mini_commit=self.mini_commit_record_iter_changes)
+            expect_fs_hash=True)
 
     def test_last_modified_revision_after_reparent_link_changes(self):
         # reparenting a link changes the last modified.
         self.requireFeature(features.SymlinkFeature)
         tree = self.make_branch_and_tree('.')
         os.symlink('target', 'link')
-        self._add_commit_reparent_check_changed(tree, 'link',
-            mini_commit=self.mini_commit_record_iter_changes)
+        self._add_commit_reparent_check_changed(tree, 'link')
 
-    def _add_commit_change_check_changed(self, tree, name, changer,
-            expect_fs_hash=False, mini_commit=None):
-        tree.add([name])
-        file_id = tree.path2id(name)
-        self.assertIsNot(None, file_id)
+    def _add_commit_change_check_changed(self, tree, names, changer,
+            expect_fs_hash=False):
+        tree.add([names[0]])
+        self.assertTrue(tree.is_versioned(names[0]))
         self._commit_change_check_changed(
-            tree, name, file_id,
-            changer, expect_fs_hash=expect_fs_hash, mini_commit=mini_commit)
+            tree, names,
+            changer, expect_fs_hash=expect_fs_hash)
 
-    def _commit_change_check_changed(self, tree, name, file_id, changer,
-        expect_fs_hash=False, mini_commit=None):
-        rev1 = tree.commit('')
+    def _commit_change_check_changed(self, tree, names, changer,
+                                     expect_fs_hash=False):
+        rev1 = tree.commit('rev1')
         changer()
-        rev2 = mini_commit(tree, name, tree.id2path(file_id),
-            expect_fs_hash=expect_fs_hash)
+        rev2 = self.mini_commit_record_iter_changes(
+                tree, names[0], names[1], expect_fs_hash=expect_fs_hash)
         tree1, tree2 = self._get_revtrees(tree, [rev1, rev2])
-        self.assertEqual(rev1, tree1.get_file_revision(tree1.id2path(file_id)))
-        self.assertEqual(rev2, tree2.get_file_revision(tree2.id2path(file_id)))
+        self.assertEqual(rev1, tree1.get_file_revision(names[0]))
+        self.assertEqual(rev2, tree2.get_file_revision(names[1]))
+        file_id = tree1.path2id(names[0])
         expected_graph = {}
         expected_graph[(file_id, rev1)] = ()
         expected_graph[(file_id, rev2)] = ((file_id, rev1),)
@@ -488,6 +480,7 @@
             # record_iter_changes
             parent_ids = tree.get_parent_ids()
             builder = tree.branch.get_commit_builder(parent_ids)
+<<<<<<< TREE
             try:
                 parent_tree = tree.basis_tree()
                 parent_tree.lock_read()
@@ -521,6 +514,36 @@
             except:
                 builder.abort()
                 raise
+=======
+            try:
+                parent_tree = tree.basis_tree()
+                with parent_tree.lock_read():
+                    changes = list(tree.iter_changes(parent_tree))
+                result = list(builder.record_iter_changes(tree, parent_ids[0],
+                    changes))
+                file_id = tree.path2id(new_name)
+                self.assertIsNot(None, file_id)
+                if expect_fs_hash:
+                    tree_file_stat = tree.get_file_with_stat(new_name)
+                    tree_file_stat[0].close()
+                    self.assertLength(1, result)
+                    result = result[0]
+                    self.assertEqual(result[:2], (file_id, new_name))
+                    self.assertEqual(result[2][0], tree.get_file_sha1(new_name))
+                    self.assertEqualStat(result[2][1], tree_file_stat[1])
+                else:
+                    self.assertEqual([], result)
+                builder.finish_inventory()
+                if tree.branch.repository._format.supports_full_versioned_files:
+                    inv_key = (builder._new_revision_id,)
+                    inv_sha1 = tree.branch.repository.inventories.get_sha1s(
+                                    [inv_key])[inv_key]
+                    self.assertEqual(inv_sha1, builder.inv_sha1)
+                rev2 = builder.commit('rev2')
+            except BaseException:
+                builder.abort()
+                raise
+>>>>>>> MERGE-SOURCE
             delta = builder.get_basis_delta()
             delta_dict = dict((change[2], change) for change in delta)
             version_recorded = (file_id in delta_dict and
@@ -531,11 +554,20 @@
             else:
                 self.assertFalse(version_recorded)
 
+<<<<<<< TREE
             revtree = builder.revision_tree()
             new_entry = revtree.iter_entries_by_dir(specific_file_ids=[file_id]).next()[1]
 
+=======
+            revtree = builder.revision_tree()
+            new_entry = revtree.iter_entries_by_dir(specific_files=[new_name]).next()[1]
+
+>>>>>>> MERGE-SOURCE
             if delta_against_basis:
-                expected_delta = (name, new_name, file_id, new_entry)
+                if tree.supports_rename_tracking() or name == new_name:
+                    expected_delta = (name, new_name, file_id, new_entry)
+                else:
+                    expected_delta = (None, new_name, file_id, new_entry)
                 self.assertEqual(expected_delta, delta_dict[file_id])
             else:
                 expected_delta = None
@@ -557,9 +589,8 @@
         self.build_tree(['file'])
         def change_file():
             tree.put_file_bytes_non_atomic('file', 'new content')
-        self._add_commit_change_check_changed(tree, 'file', change_file,
-            expect_fs_hash=True,
-            mini_commit=self.mini_commit_record_iter_changes)
+        self._add_commit_change_check_changed(tree, ('file', 'file'), change_file,
+            expect_fs_hash=True)
 
     def _test_last_mod_rev_after_content_link_changes(
         self, link, target, newtarget):
@@ -571,8 +602,7 @@
             os.unlink(link)
             os.symlink(newtarget, link)
         self._add_commit_change_check_changed(
-            tree, link, change_link,
-            mini_commit=self.mini_commit_record_iter_changes)
+            tree, (link, link), change_link)
 
     def test_last_modified_rev_after_content_link_changes(self):
         self._test_last_mod_rev_after_content_link_changes(
@@ -585,24 +615,23 @@
 
     def _commit_sprout(self, tree, name):
         tree.add([name])
-        rev_id = tree.commit('')
+        rev_id = tree.commit('rev')
         return rev_id, tree.controldir.sprout('t2').open_workingtree()
 
-    def _rename_in_tree(self, tree, name):
+    def _rename_in_tree(self, tree, name, message):
         tree.rename_one(name, 'new_' + name)
-        return tree.commit('')
+        return tree.commit(message)
 
-    def _commit_sprout_rename_merge(self, tree1, name, expect_fs_hash=False,
-        mini_commit=None):
+    def _commit_sprout_rename_merge(self, tree1, name, expect_fs_hash=False):
         """Do a rename in both trees."""
         rev1, tree2 = self._commit_sprout(tree1, name)
         file_id = tree2.path2id(name)
         self.assertIsNot(None, file_id)
         # change both sides equally
-        rev2 = self._rename_in_tree(tree1, name)
-        rev3 = self._rename_in_tree(tree2, name)
+        rev2 = self._rename_in_tree(tree1, name, 'rev2')
+        rev3 = self._rename_in_tree(tree2, name, 'rev3')
         tree1.merge_from_branch(tree2.branch)
-        rev4 = mini_commit(tree1, 'new_' + name, 'new_' + name,
+        rev4 = self.mini_commit_record_iter_changes(tree1, 'new_' + name, 'new_' + name,
             expect_fs_hash=expect_fs_hash)
         tree3, = self._get_revtrees(tree1, [rev4])
         self.assertEqual(rev4, tree3.get_file_revision(tree3.id2path(file_id)))
@@ -620,26 +649,22 @@
             raise tests.TestNotApplicable(
                     'Format does not support versioned directories')
         self.build_tree(['t1/dir/'])
-        self._commit_sprout_rename_merge(tree1, 'dir',
-            mini_commit=self.mini_commit_record_iter_changes)
+        self._commit_sprout_rename_merge(tree1, 'dir')
 
     def test_last_modified_revision_after_merge_file_changes(self):
         # merge a file changes the last modified.
         tree1 = self.make_branch_and_tree('t1')
         self.build_tree(['t1/file'])
-        self._commit_sprout_rename_merge(tree1, 'file', expect_fs_hash=True,
-            mini_commit=self.mini_commit_record_iter_changes)
+        self._commit_sprout_rename_merge(tree1, 'file', expect_fs_hash=True)
 
     def test_last_modified_revision_after_merge_link_changes(self):
         # merge a link changes the last modified.
         self.requireFeature(features.SymlinkFeature)
         tree1 = self.make_branch_and_tree('t1')
         os.symlink('target', 't1/link')
-        self._commit_sprout_rename_merge(tree1, 'link',
-            mini_commit=self.mini_commit_record_iter_changes)
+        self._commit_sprout_rename_merge(tree1, 'link')
 
-    def _commit_sprout_rename_merge_converged(self, tree1, name,
-        mini_commit=None):
+    def _commit_sprout_rename_merge_converged(self, tree1, name):
         # Make a merge which just incorporates a change from a branch:
         # The per-file graph is straight line, and no alteration occurs
         # in the inventory.
@@ -648,11 +673,12 @@
         file_id = tree2.path2id(name)
         self.assertIsNot(None, file_id)
         # change on the other side to merge back
-        rev2 = self._rename_in_tree(tree2, name)
+        rev2 = self._rename_in_tree(tree2, name, 'rev2')
         tree1.merge_from_branch(tree2.branch)
         def _check_graph(in_tree, changed_in_tree):
-            rev3 = mini_commit(in_tree, name, 'new_' + name, False,
-                delta_against_basis=changed_in_tree)
+            rev3 = self.mini_commit_record_iter_changes(
+                    in_tree, name, 'new_' + name, False,
+                    delta_against_basis=changed_in_tree)
             tree3, = self._get_revtrees(in_tree, [rev2])
             self.assertEqual(
                     rev2,
@@ -666,27 +692,27 @@
         # change to name, branch tree1 and give it an unrelated change, then
         # merge that to t2.
         other_tree = tree1.controldir.sprout('t3').open_workingtree()
-        other_rev = other_tree.commit('')
+        other_rev = other_tree.commit('other_rev')
         tree2.merge_from_branch(other_tree.branch)
         _check_graph(tree2, False)
 
-    def _commit_sprout_make_merge(self, tree1, make, mini_commit=None):
+    def _commit_sprout_make_merge(self, tree1, make):
         # Make a merge which incorporates the addition of a new object to
         # another branch. The per-file graph shows no additional change
         # in the merge because its a straight line.
-        rev1 = tree1.commit('')
+        rev1 = tree1.commit('rev1')
         tree2 = tree1.controldir.sprout('t2').open_workingtree()
         # make and commit on the other side to merge back
         make('t2/name')
         tree2.add(['name'])
-        file_id = tree2.path2id('name')
-        self.assertIsNot(None, file_id)
-        rev2 = tree2.commit('')
+        self.assertTrue(tree2.is_versioned('name'))
+        rev2 = tree2.commit('rev2')
         tree1.merge_from_branch(tree2.branch)
-        rev3 = mini_commit(tree1, None, 'name', False)
+        rev3 = self.mini_commit_record_iter_changes(tree1, None, 'name', False)
         tree3, = self._get_revtrees(tree1, [rev2])
         # in rev2, name should be only changed in rev2
-        self.assertEqual(rev2, tree3.get_file_revision(tree3.id2path(file_id)))
+        self.assertEqual(rev2, tree3.get_file_revision('name'))
+        file_id = tree2.path2id('name')
         expected_graph = {}
         expected_graph[(file_id, rev2)] = ()
         self.assertFileGraph(expected_graph, tree1, (file_id, rev2))
@@ -698,41 +724,38 @@
             raise tests.TestNotApplicable(
                     'Format does not support versioned directories')
         self.build_tree(['t1/dir/'])
-        self._commit_sprout_rename_merge_converged(tree1, 'dir',
-            mini_commit=self.mini_commit_record_iter_changes)
+        self._commit_sprout_rename_merge_converged(tree1, 'dir')
 
     def test_last_modified_revision_after_converged_merge_file_unchanged(self):
         # merge a file that changed preserves the last modified.
         tree1 = self.make_branch_and_tree('t1')
         self.build_tree(['t1/file'])
-        self._commit_sprout_rename_merge_converged(tree1, 'file',
-            mini_commit=self.mini_commit_record_iter_changes)
+        self._commit_sprout_rename_merge_converged(tree1, 'file')
 
     def test_last_modified_revision_after_converged_merge_link_unchanged(self):
         # merge a link that changed preserves the last modified.
         self.requireFeature(features.SymlinkFeature)
         tree1 = self.make_branch_and_tree('t1')
         os.symlink('target', 't1/link')
-        self._commit_sprout_rename_merge_converged(tree1, 'link',
-            mini_commit=self.mini_commit_record_iter_changes)
+        self._commit_sprout_rename_merge_converged(tree1, 'link')
 
     def test_last_modified_revision_after_merge_new_dir_unchanged(self):
         # merge a new dir does not change the last modified.
         tree1 = self.make_branch_and_tree('t1')
-        self._commit_sprout_make_merge(tree1, self.make_dir,
-            mini_commit=self.mini_commit_record_iter_changes)
+        if not tree1.has_versioned_directories():
+            raise tests.TestNotApplicable(
+                    'Format does not support versioned directories')
+        self._commit_sprout_make_merge(tree1, self.make_dir)
 
     def test_last_modified_revision_after_merge_new_file_unchanged(self):
         # merge a new file does not change the last modified.
         tree1 = self.make_branch_and_tree('t1')
-        self._commit_sprout_make_merge(tree1, self.make_file,
-            mini_commit=self.mini_commit_record_iter_changes)
+        self._commit_sprout_make_merge(tree1, self.make_file)
 
     def test_last_modified_revision_after_merge_new_link_unchanged(self):
         # merge a new link does not change the last modified.
         tree1 = self.make_branch_and_tree('t1')
-        self._commit_sprout_make_merge(tree1, self.make_link,
-            mini_commit=self.mini_commit_record_iter_changes)
+        self._commit_sprout_make_merge(tree1, self.make_link)
 
     def make_dir(self, name):
         self.build_tree([name + '/'])
@@ -749,8 +772,7 @@
         tree.commit('foo')
         return tree
 
-    def _check_kind_change(self, make_before, make_after, expect_fs_hash=False,
-        mini_commit=None):
+    def _check_kind_change(self, make_before, make_after, expect_fs_hash=False):
         tree = self.make_branch_and_tree('.')
         path = 'name'
         make_before(path)
@@ -762,8 +784,8 @@
                 osutils.delete_any(path)
             make_after(path)
 
-        self._add_commit_change_check_changed(tree, path, change_kind,
-            expect_fs_hash=expect_fs_hash, mini_commit=mini_commit)
+        self._add_commit_change_check_changed(tree, (path, path), change_kind,
+            expect_fs_hash=expect_fs_hash)
 
     def test_last_modified_dir_file(self):
         if not self.repository_format.supports_versioned_directories:
@@ -773,8 +795,7 @@
                 'format does not support versioned directories')
         try:
             self._check_kind_change(self.make_dir, self.make_file,
-                expect_fs_hash=True,
-                mini_commit=self.mini_commit_record_iter_changes)
+                expect_fs_hash=True)
         except errors.UnsupportedKindChange:
             raise tests.TestSkipped(
                 "tree does not support changing entry kind from "
@@ -787,8 +808,7 @@
             raise tests.TestNotApplicable(
                 'format does not support versioned directories')
         try:
-            self._check_kind_change(self.make_dir, self.make_link,
-                mini_commit=self.mini_commit_record_iter_changes)
+            self._check_kind_change(self.make_dir, self.make_link)
         except errors.UnsupportedKindChange:
             raise tests.TestSkipped(
                 "tree does not support changing entry kind from "
@@ -796,8 +816,7 @@
 
     def test_last_modified_link_file(self):
         self._check_kind_change(self.make_link, self.make_file,
-            expect_fs_hash=True,
-            mini_commit=self.mini_commit_record_iter_changes)
+            expect_fs_hash=True)
 
     def test_last_modified_link_dir(self):
         if not self.repository_format.supports_versioned_directories:
@@ -806,8 +825,7 @@
             raise tests.TestNotApplicable(
                 'format does not support versioned directories')
 
-        self._check_kind_change(self.make_link, self.make_dir,
-            mini_commit=self.mini_commit_record_iter_changes)
+        self._check_kind_change(self.make_link, self.make_dir)
 
     def test_last_modified_file_dir(self):
         if not self.repository_format.supports_versioned_directories:
@@ -816,12 +834,10 @@
             raise tests.TestNotApplicable(
                 'format does not support versioned directories')
 
-        self._check_kind_change(self.make_file, self.make_dir,
-            mini_commit=self.mini_commit_record_iter_changes)
+        self._check_kind_change(self.make_file, self.make_dir)
 
     def test_last_modified_file_link(self):
-        self._check_kind_change(self.make_file, self.make_link,
-            mini_commit=self.mini_commit_record_iter_changes)
+        self._check_kind_change(self.make_file, self.make_link)
 
     def test_get_commit_builder_with_invalid_revprops(self):
         branch = self.make_branch('.')

=== modified file 'breezy/tests/per_repository_vf/test_fileid_involved.py'
--- breezy/tests/per_repository_vf/test_fileid_involved.py	2017-11-16 10:35:32 +0000
+++ breezy/tests/per_repository_vf/test_fileid_involved.py	2018-03-24 17:11:56 +0000
@@ -429,10 +429,9 @@
     os.chmod() doesn't work on windows. But TreeTransform can mark or
     unmark a file as executable.
     """
-    file_id = wt.path2id(path)
     tt = transform.TreeTransform(wt)
     try:
-        tt.set_executability(executable, tt.trans_id_tree_file_id(file_id))
+        tt.set_executability(executable, tt.trans_id_tree_path(path))
         tt.apply()
     finally:
         tt.finalize()

=== modified file 'breezy/tests/per_tree/__init__.py'
--- breezy/tests/per_tree/__init__.py	2018-02-21 02:35:42 +0000
+++ breezy/tests/per_tree/__init__.py	2018-03-24 17:11:56 +0000
@@ -277,56 +277,6 @@
         tt.apply()
         return self.workingtree_to_test_tree(tree)
 
-    def get_tree_with_utf8(self, tree):
-        """Generate a tree with a utf8 revision and unicode paths."""
-        self._create_tree_with_utf8(tree)
-        return self.workingtree_to_test_tree(tree)
-
-    def _create_tree_with_utf8(self, tree):
-        """Generate a tree with a utf8 revision and unicode paths."""
-        self.requireFeature(features.UnicodeFilenameFeature)
-        # We avoid combining characters in file names here, normalization
-        # checks (as performed by some file systems (OSX) are outside the scope
-        # of these tests).  We use the euro sign \N{Euro Sign} or \u20ac in
-        # unicode strings or '\xe2\x82\ac' (its utf-8 encoding) in raw strings.
-        paths = [u'',
-                 u'fo\N{Euro Sign}o',
-                 u'ba\N{Euro Sign}r/',
-                 u'ba\N{Euro Sign}r/ba\N{Euro Sign}z',
-                ]
-        # bzr itself does not create unicode file ids, but we want them for
-        # testing.
-        file_ids = ['TREE_ROOT',
-                    'fo\xe2\x82\xaco-id',
-                    'ba\xe2\x82\xacr-id',
-                    'ba\xe2\x82\xacz-id',
-                   ]
-        self.build_tree(paths[1:])
-        if tree.get_root_id() is None:
-            # Some trees do not have a root yet.
-            tree.add(paths, file_ids)
-        else:
-            # Some trees will already have a root
-            tree.set_root_id(file_ids[0])
-            tree.add(paths[1:], file_ids[1:])
-        try:
-            tree.commit(u'in\xedtial', rev_id=u'r\xe9v-1'.encode('utf8'))
-        except errors.NonAsciiRevisionId:
-            raise tests.TestSkipped('non-ascii revision ids not supported')
-
-    def get_tree_with_merged_utf8(self, tree):
-        """Generate a tree with utf8 ancestors."""
-        self._create_tree_with_utf8(tree)
-        tree2 = tree.controldir.sprout('tree2').open_workingtree()
-        self.build_tree([u'tree2/ba\N{Euro Sign}r/qu\N{Euro Sign}x'])
-        tree2.add([u'ba\N{Euro Sign}r/qu\N{Euro Sign}x'],
-                  [u'qu\N{Euro Sign}x-id'.encode('utf-8')])
-        tree2.commit(u'to m\xe9rge', rev_id=u'r\xe9v-2'.encode('utf8'))
-
-        tree.merge_from_branch(tree2.branch)
-        tree.commit(u'm\xe9rge', rev_id=u'r\xe9v-3'.encode('utf8'))
-        return self.workingtree_to_test_tree(tree)
-
 
 def make_scenarios(transport_server, transport_readonly_server, formats):
     """Generate test suites for each Tree implementation in breezy.

=== modified file 'breezy/tests/per_tree/test_inv.py'
--- breezy/tests/per_tree/test_inv.py	2017-08-01 01:44:41 +0000
+++ breezy/tests/per_tree/test_inv.py	2018-03-24 17:11:56 +0000
@@ -33,8 +33,8 @@
     )
 
 
-def get_entry(tree, file_id):
-    return tree.iter_entries_by_dir([file_id]).next()[1]
+def get_entry(tree, path):
+    return tree.iter_entries_by_dir(specific_files=[path]).next()[1]
 
 
 class TestInventoryWithSymlinks(per_tree.TestCaseWithTree):
@@ -52,7 +52,7 @@
             raise TestSkipped(
                 'symlinks not accurately represented in working trees and'
                 ' preview trees')
-        entry = get_entry(self.tree, self.tree.path2id('symlink'))
+        entry = get_entry(self.tree, 'symlink')
         self.assertEqual(entry.symlink_target, 'link-target')
 
     def test_symlink_target_tree(self):
@@ -64,7 +64,7 @@
         self.assertIs(None, self.tree.get_file_size('symlink'))
 
     def test_symlink(self):
-        entry = get_entry(self.tree, self.tree.path2id('symlink'))
+        entry = get_entry(self.tree, 'symlink')
         self.assertEqual(entry.kind, 'symlink')
         self.assertEqual(None, entry.text_size)
 
@@ -76,6 +76,9 @@
         self.build_tree(['tree/dir/', 'tree/dir/file'])
         work_tree.add(['dir', 'dir/file'])
         tree = self._convert_tree(work_tree)
+        if not isinstance(tree, InventoryTree):
+            raise tests.TestNotApplicable(
+                "test not applicable on non-inventory tests")
         tree.lock_read()
         self.addCleanup(tree.unlock)
         self.assertEqual({tree.path2id('dir'), tree.path2id('dir/file')},
@@ -88,6 +91,9 @@
         work_tree.commit('commit old state')
         work_tree.remove('file')
         tree = self._convert_tree(work_tree)
+        if not isinstance(tree, InventoryTree):
+            raise tests.TestNotApplicable(
+                "test not applicable on non-inventory tests")
         tree.lock_read()
         self.addCleanup(tree.unlock)
         self.assertEqual(set([]), tree.paths2ids(['file'],

=== modified file 'breezy/tests/per_tree/test_test_trees.py'
--- breezy/tests/per_tree/test_test_trees.py	2018-03-02 16:32:39 +0000
+++ breezy/tests/per_tree/test_test_trees.py	2018-03-24 17:11:56 +0000
@@ -16,9 +16,11 @@
 
 """Tests for the test trees used by the per_tree tests."""
 
+from breezy import errors
 from breezy.tests import per_tree
 from breezy.tests import (
     TestNotApplicable,
+    TestSkipped,
     features,
     )
 
@@ -138,7 +140,10 @@
         self.addCleanup(tree.unlock)
         self.assertEqual([], tree.get_parent_ids())
         self.assertEqual([], tree.conflicts())
-        self.assertEqual([], list(tree.unknowns()))
+        if tree.has_versioned_directories():
+            self.assertEqual([], list(tree.unknowns()))
+        else:
+            self.assertEqual(['b'], list(tree.unknowns()))
         # __iter__ has no strongly defined order
         expected_paths = (
                 ['', 'a'] +
@@ -163,25 +168,45 @@
         self.addCleanup(tree.unlock)
         self.assertEqual([], tree.get_parent_ids())
         self.assertEqual([], tree.conflicts())
-        self.assertEqual([], list(tree.unknowns()))
+        if tree.has_versioned_directories():
+            self.assertEqual([], list(tree.unknowns()))
+        else:
+            self.assertEqual(['1top-dir/1dir-in-1topdir'], list(tree.unknowns()))
         # __iter__ has no strongly defined order
         tree_root = tree.path2id('')
-        self.assertEqual(
-            {tree.path2id(p) for p in [
-                '', '0file', '1top-dir', '1top-dir/1dir-in-1topdir',
-                '1top-dir/0file-in-1topdir', 'symlink', u'2utf\u1234file']},
-            set(tree.all_file_ids()))
-        # note that the order of the paths and fileids is deliberately
-        # mismatched to ensure that the result order is path based.
-        self.assertEqual(
-            [('', 'directory'),
-             ('0file', 'file'),
-             ('1top-dir', 'directory'),
-             (u'2utf\u1234file', 'file'),
-             ('symlink', 'symlink'),
-             ('1top-dir/0file-in-1topdir', 'file'),
-             ('1top-dir/1dir-in-1topdir', 'directory')],
-            [(path, node.kind) for path, node in tree.iter_entries_by_dir()])
+        if tree.has_versioned_directories():
+            self.assertEqual(
+                {tree.path2id(p) for p in [
+                    '', '0file', '1top-dir', '1top-dir/1dir-in-1topdir',
+                    '1top-dir/0file-in-1topdir', 'symlink', u'2utf\u1234file']},
+                set(tree.all_file_ids()))
+            # note that the order of the paths and fileids is deliberately
+            # mismatched to ensure that the result order is path based.
+            self.assertEqual(
+                [('', 'directory'),
+                 ('0file', 'file'),
+                 ('1top-dir', 'directory'),
+                 (u'2utf\u1234file', 'file'),
+                 ('symlink', 'symlink'),
+                 ('1top-dir/0file-in-1topdir', 'file'),
+                 ('1top-dir/1dir-in-1topdir', 'directory')],
+                [(path, node.kind) for path, node in tree.iter_entries_by_dir()])
+        else:
+            self.assertEqual(
+                {tree.path2id(p) for p in [
+                    '', '0file', '1top-dir', 
+                    '1top-dir/0file-in-1topdir', 'symlink', u'2utf\u1234file']},
+                set(tree.all_file_ids()))
+            # note that the order of the paths and fileids is deliberately
+            # mismatched to ensure that the result order is path based.
+            self.assertEqual(
+                [('', 'directory'),
+                 ('0file', 'file'),
+                 ('1top-dir', 'directory'),
+                 (u'2utf\u1234file', 'file'),
+                 ('symlink', 'symlink'),
+                 ('1top-dir/0file-in-1topdir', 'file')],
+                [(path, node.kind) for path, node in tree.iter_entries_by_dir()])
 
     def test_tree_with_subdirs_and_all_content_types_wo_symlinks(self):
         # currently this test tree requires unicode. It might be good
@@ -192,30 +217,90 @@
         self.addCleanup(tree.unlock)
         self.assertEqual([], tree.get_parent_ids())
         self.assertEqual([], tree.conflicts())
-        self.assertEqual([], list(tree.unknowns()))
+        if tree.has_versioned_directories():
+            self.assertEqual([], list(tree.unknowns()))
+        else:
+            self.assertEqual(['1top-dir/1dir-in-1topdir'], list(tree.unknowns()))
         # __iter__ has no strongly defined order
         tree_root = tree.path2id('')
-        self.assertEqual(
-            {'', '0file', '1top-dir', '1top-dir/0file-in-1topdir',
-             '1top-dir/1dir-in-1topdir', u'2utf\u1234file'},
-            set(tree.all_versioned_paths()))
-        # note that the order of the paths and fileids is deliberately
-        # mismatched to ensure that the result order is path based.
-        self.assertEqual(
-            [('', 'directory'),
-             ('0file', 'file'),
-             ('1top-dir', 'directory'),
-             (u'2utf\u1234file', 'file'),
-             ('1top-dir/0file-in-1topdir', 'file'),
-             ('1top-dir/1dir-in-1topdir', 'directory')],
-            [(path, node.kind) for path, node in tree.iter_entries_by_dir()])
+        if tree.has_versioned_directories():
+            self.assertEqual(
+                {'', '0file', '1top-dir', '1top-dir/0file-in-1topdir',
+                 '1top-dir/1dir-in-1topdir', u'2utf\u1234file'},
+                set(tree.all_versioned_paths()))
+            # note that the order of the paths and fileids is deliberately
+            # mismatched to ensure that the result order is path based.
+            self.assertEqual(
+                [('', 'directory'),
+                 ('0file', 'file'),
+                 ('1top-dir', 'directory'),
+                 (u'2utf\u1234file', 'file'),
+                 ('1top-dir/0file-in-1topdir', 'file'),
+                 ('1top-dir/1dir-in-1topdir', 'directory')],
+                [(path, node.kind) for path, node in tree.iter_entries_by_dir()])
+        else:
+            self.assertEqual(
+                {'', '0file', '1top-dir', '1top-dir/0file-in-1topdir',
+                 u'2utf\u1234file'},
+                set(tree.all_versioned_paths()))
+            # note that the order of the paths and fileids is deliberately
+            # mismatched to ensure that the result order is path based.
+            self.assertEqual(
+                [('', 'directory'),
+                 ('0file', 'file'),
+                 ('1top-dir', 'directory'),
+                 (u'2utf\u1234file', 'file'),
+                 ('1top-dir/0file-in-1topdir', 'file')],
+                [(path, node.kind) for path, node in tree.iter_entries_by_dir()])
+
+    def _create_tree_with_utf8(self, tree):
+        self.requireFeature(features.UnicodeFilenameFeature)
+
+        # We avoid combining characters in file names here, normalization
+        # checks (as performed by some file systems (OSX) are outside the scope
+        # of these tests).  We use the euro sign \N{Euro Sign} or \u20ac in
+        # unicode strings or '\xe2\x82\ac' (its utf-8 encoding) in raw strings.
+        paths = [u'',
+                 u'fo\N{Euro Sign}o',
+                 u'ba\N{Euro Sign}r/',
+                 u'ba\N{Euro Sign}r/ba\N{Euro Sign}z',
+                ]
+        # bzr itself does not create unicode file ids, but we want them for
+        # testing.
+        file_ids = ['TREE_ROOT',
+                    'fo\xe2\x82\xaco-id',
+                    'ba\xe2\x82\xacr-id',
+                    'ba\xe2\x82\xacz-id',
+                   ]
+        self.build_tree(paths[1:])
+        if tree.get_root_id() is None:
+            # Some trees do not have a root yet.
+            tree.add(paths, file_ids)
+        else:
+            # Some trees will already have a root
+            if tree.supports_setting_file_ids():
+                tree.set_root_id(file_ids[0])
+                tree.add(paths[1:], file_ids[1:])
+            else:
+                tree.add(paths[1:])
+        if tree.branch.repository._format.supports_setting_revision_ids:
+            try:
+                tree.commit(u'in\xedtial', rev_id=u'r\xe9v-1'.encode('utf8'))
+            except errors.NonAsciiRevisionId:
+                raise TestSkipped('non-ascii revision ids not supported')
+        else:
+            tree.commit(u'in\xedtial')
+
+        return tree
 
     def test_tree_with_utf8(self):
         tree = self.make_branch_and_tree('.')
         if not tree.supports_setting_file_ids():
             raise TestNotApplicable(
                 'format does not support custom file ids')
-        tree = self.get_tree_with_utf8(tree)
+        self._create_tree_with_utf8(tree)
+
+        tree = self.workingtree_to_test_tree(tree)
 
         revision_id = u'r\xe9v-1'.encode('utf8')
         root_id = 'TREE_ROOT'
@@ -228,11 +313,8 @@
                         (u'ba\N{Euro Sign}r/ba\N{Euro Sign}z',
                          baz_id, bar_id, revision_id),
                        ]
-        tree.lock_read()
-        try:
+        with tree.lock_read():
             path_entries = list(tree.iter_entries_by_dir())
-        finally:
-            tree.unlock()
 
         for expected, (path, ie) in zip(path_and_ids, path_entries):
             self.assertEqual(expected[0], path) # Paths should match
@@ -258,8 +340,31 @@
             self.assertIsInstance(last_revision(), str)
 
     def test_tree_with_merged_utf8(self):
-        tree = self.make_branch_and_tree('.')
-        tree = self.get_tree_with_merged_utf8(tree)
+        wt = self.make_branch_and_tree('.')
+
+        self._create_tree_with_utf8(wt)
+
+        tree2 = wt.controldir.sprout('tree2').open_workingtree()
+        self.build_tree([u'tree2/ba\N{Euro Sign}r/qu\N{Euro Sign}x'])
+        if wt.supports_setting_file_ids():
+            tree2.add([u'ba\N{Euro Sign}r/qu\N{Euro Sign}x'],
+                      [u'qu\N{Euro Sign}x-id'.encode('utf-8')])
+        else:
+            tree2.add([u'ba\N{Euro Sign}r/qu\N{Euro Sign}x'])
+        if wt.branch.repository._format.supports_setting_revision_ids:
+            tree2.commit(u'to m\xe9rge', rev_id=u'r\xe9v-2'.encode('utf8'))
+        else:
+            tree2.commit(u'to m\xe9rge')
+
+        self.assertTrue(tree2.is_versioned(u'ba\N{Euro Sign}r/qu\N{Euro Sign}x'))
+        wt.merge_from_branch(tree2.branch)
+        self.assertTrue(wt.is_versioned(u'ba\N{Euro Sign}r/qu\N{Euro Sign}x'))
+
+        if wt.branch.repository._format.supports_setting_revision_ids:
+            wt.commit(u'm\xe9rge', rev_id=u'r\xe9v-3'.encode('utf8'))
+        else:
+            wt.commit(u'm\xe9rge')
+        tree = self.workingtree_to_test_tree(wt)
 
         revision_id_1 = u'r\xe9v-1'.encode('utf8')
         revision_id_2 = u'r\xe9v-2'.encode('utf8')
@@ -276,21 +381,19 @@
                         (u'ba\N{Euro Sign}r/qu\N{Euro Sign}x',
                          qux_id, bar_id, revision_id_2),
                        ]
-        tree.lock_read()
-        try:
+        with tree.lock_read():
             path_entries = list(tree.iter_entries_by_dir())
-        finally:
-            tree.unlock()
 
         for (epath, efid, eparent, erev), (path, ie) in zip(path_and_ids,
                                                             path_entries):
             self.assertEqual(epath, path) # Paths should match
             self.assertIsInstance(path, unicode)
-            self.assertEqual(efid, ie.file_id)
-            self.assertIsInstance(ie.file_id, str)
-            self.assertEqual(eparent, ie.parent_id)
+            self.assertIsInstance(ie.file_id, bytes)
+            if wt.supports_setting_file_ids():
+                self.assertEqual(efid, ie.file_id)
+                self.assertEqual(eparent, ie.parent_id)
             if eparent is not None:
-                self.assertIsInstance(ie.parent_id, str)
+                self.assertIsInstance(ie.parent_id, bytes)
             # WorkingTree's return None for the last modified revision
             if ie.revision is not None:
                 self.assertIsInstance(ie.revision, str)
@@ -299,10 +402,13 @@
                     # but not all will
                     continue
                 self.assertEqual(erev, ie.revision)
-        self.assertEqual(len(path_and_ids), len(path_entries))
+        self.assertEqual(len(path_and_ids), len(path_entries),
+                         "%r vs %r" % (
+                             [p for (p, f, pf, r) in path_and_ids],
+                             [p for (p, e) in path_entries]))
         get_revision_id = getattr(tree, 'get_revision_id', None)
         if get_revision_id is not None:
-            self.assertIsInstance(get_revision_id(), str)
+            self.assertIsInstance(get_revision_id(), bytes)
         last_revision = getattr(tree, 'last_revision', None)
         if last_revision is not None:
-            self.assertIsInstance(last_revision(), str)
+            self.assertIsInstance(last_revision(), bytes)

=== modified file 'breezy/tests/per_tree/test_tree.py'
--- breezy/tests/per_tree/test_tree.py	2018-03-04 17:22:37 +0000
+++ breezy/tests/per_tree/test_tree.py	2018-03-24 17:11:56 +0000
@@ -359,4 +359,12 @@
     def test_has_versioned_directories(self):
         work_tree = self.make_branch_and_tree('tree')
         tree = self._convert_tree(work_tree)
-        self.assertSubset([tree.has_versioned_directories()], (True, False))
+        self.assertIn(tree.has_versioned_directories(), (True, False))
+
+
+class TestSupportsRenameTracking(TestCaseWithTree):
+
+    def test_supports_rename_tracking(self):
+        work_tree = self.make_branch_and_tree('tree')
+        tree = self._convert_tree(work_tree)
+        self.assertSubset([tree.supports_rename_tracking()], (True, False))

=== modified file 'breezy/tests/per_tree/test_walkdirs.py'
--- breezy/tests/per_tree/test_walkdirs.py	2018-03-12 05:56:02 +0000
+++ breezy/tests/per_tree/test_walkdirs.py	2018-03-24 17:11:56 +0000
@@ -48,7 +48,7 @@
             ]
         if symlinks:
             dirblocks[0][1].append(('symlink', 'symlink', 'symlink', None,
-                                    'symlink', 'symlink'))
+                                    tree.path2id('symlink'), 'symlink'))
         return dirblocks
 
     def test_walkdir_root(self):

=== modified file 'breezy/tests/per_workingtree/test_check_state.py'
--- breezy/tests/per_workingtree/test_check_state.py	2017-05-21 18:10:28 +0000
+++ breezy/tests/per_workingtree/test_check_state.py	2018-03-24 17:11:56 +0000
@@ -81,8 +81,11 @@
         tree = self.make_initial_tree()
         foo_id = tree.path2id('foo')
         tree.rename_one('foo', 'baz')
-        self.assertEqual(None, tree.path2id('foo'))
-        self.assertEqual(foo_id, tree.path2id('baz'))
+        self.assertFalse(tree.is_versioned('foo'))
+        if tree.supports_rename_tracking():
+            self.assertEqual(foo_id, tree.path2id('baz'))
+        else:
+            self.assertTrue(tree.is_versioned('baz'))
         tree.reset_state()
         # After reset, we should have forgotten about the rename, but we won't
         # have

=== modified file 'breezy/tests/per_workingtree/test_executable.py'
=== modified file 'breezy/tests/per_workingtree/test_inv.py'
--- breezy/tests/per_workingtree/test_inv.py	2018-02-15 19:38:33 +0000
+++ breezy/tests/per_workingtree/test_inv.py	2018-03-24 17:11:56 +0000
@@ -178,6 +178,6 @@
         # wt.current_dirstate()'s idea about what files are where.
         ie = base.inventory['subdir-id']
         self.assertEqual('directory', ie.kind)
-        path, ie = next(base.iter_entries_by_dir(['subdir-id']))
+        path, ie = next(base.iter_entries_by_dir(specific_files=['subdir']))
         self.assertEqual('subdir', path)
         self.assertEqual('tree-reference', ie.kind)

=== modified file 'breezy/tests/per_workingtree/test_merge_from_branch.py'
--- breezy/tests/per_workingtree/test_merge_from_branch.py	2018-03-08 02:01:07 +0000
+++ breezy/tests/per_workingtree/test_merge_from_branch.py	2018-03-24 17:11:56 +0000
@@ -111,7 +111,7 @@
         self.build_tree_contents([('this/foo', 'baz')])
         this.commit('content -> baz')
         class QuxMerge(merge.Merge3Merger):
-            def text_merge(self, file_id, trans_id):
+            def text_merge(self, trans_id, paths, file_id):
                 self.tt.create_file('qux', trans_id)
         this.merge_from_branch(other.branch, merge_type=QuxMerge)
         self.assertEqual('qux', this.get_file_text('foo'))

=== modified file 'breezy/tests/per_workingtree/test_move.py'
--- breezy/tests/per_workingtree/test_move.py	2018-03-12 05:18:13 +0000
+++ breezy/tests/per_workingtree/test_move.py	2018-03-24 17:11:56 +0000
@@ -137,13 +137,25 @@
                           tree.move, ['d', 'c', 'b'], 'a')
         if osutils.lexists('a/c'):
             # If 'c' was actually moved, then 'd' should have also been moved
+<<<<<<< TREE
             self.assertPathRelations(
                 tree.basis_tree(), tree,
                 [('', ''), ('a/', 'a'), ('a/c', 'c'), ('a/d', 'd')])
+=======
+            self.assertPathRelations(
+                tree.basis_tree(), tree,
+                [('', ''), ('a/', 'a/'), ('a/c', 'c'), ('a/d', 'd')])
+>>>>>>> MERGE-SOURCE
         else:
+<<<<<<< TREE
             self.assertPathRelations(
                 tree.basis_tree(), tree,
                 [('', ''), ( 'a/', 'a'), ('c', 'c'), ('d', 'd')])
+=======
+            self.assertPathRelations(
+                tree.basis_tree(), tree,
+                [('', ''), ( 'a/', 'a/'), ('c', 'c'), ('d', 'd')])
+>>>>>>> MERGE-SOURCE
         tree._validate()
 
     def test_move_over_deleted(self):
@@ -154,9 +166,15 @@
 
         tree.remove(['a/b'], keep_files=False)
         self.assertEqual([('b', 'a/b')], tree.move(['b'], 'a'))
+<<<<<<< TREE
         self.assertPathRelations(
                 tree.basis_tree(), tree,
                 [('', ''), ('a/', 'a'), ('a/b', 'b')])
+=======
+        self.assertPathRelations(
+                tree.basis_tree(), tree,
+                [('', ''), ('a/', 'a/'), ('a/b', 'b')])
+>>>>>>> MERGE-SOURCE
         tree._validate()
 
     def test_move_subdir(self):
@@ -164,6 +182,7 @@
         self.build_tree(['a', 'b/', 'b/c'])
         tree.add(['a', 'b', 'b/c'])
         tree.commit('initial')
+<<<<<<< TREE
         self.assertPathRelations(
                 tree.basis_tree(), tree,
                 [('', ''), ('a', 'a'), ('b/', 'b'), ('b/c', 'b/c')])
@@ -172,6 +191,16 @@
         self.assertPathRelations(
                 tree.basis_tree(), tree,
                 [('', ''), ('b/', 'b'), ('b/a', 'a'), ('b/c', 'b/c')])
+=======
+        self.assertPathRelations(
+                tree.basis_tree(), tree,
+                [('', ''), ('a', 'a'), ('b/', 'b/'), ('b/c', 'b/c')])
+        a_contents = tree.get_file_text('a')
+        self.assertEqual([('a', 'b/a')], tree.move(['a'], 'b'))
+        self.assertPathRelations(
+                tree.basis_tree(), tree,
+                [('', ''), ('b/', 'b/'), ('b/a', 'a'), ('b/c', 'b/c')])
+>>>>>>> MERGE-SOURCE
         self.assertPathDoesNotExist('a')
         self.assertFileEqual(a_contents, 'b/a')
         tree._validate()
@@ -184,9 +213,15 @@
         c_contents = tree.get_file_text('b/c')
         self.assertEqual([('b/c', 'c')],
             tree.move(['b/c'], ''))
+<<<<<<< TREE
         self.assertPathRelations(
                 tree.basis_tree(), tree,
                 [('', ''), ('a', 'a'), ('b/', 'b'), ('c', 'b/c')])
+=======
+        self.assertPathRelations(
+                tree.basis_tree(), tree,
+                [('', ''), ('a', 'a'), ('b/', 'b/'), ('c', 'b/c')])
+>>>>>>> MERGE-SOURCE
         self.assertPathDoesNotExist('b/c')
         self.assertFileEqual(c_contents, 'c')
         tree._validate()
@@ -202,14 +237,26 @@
         # 'c' may or may not have been moved, but either way the tree should
         # maintain a consistent state.
         if osutils.lexists('c'):
+<<<<<<< TREE
             self.assertPathRelations(
                     tree.basis_tree(), tree,
                     [('', ''), ('a', 'a'), ('b/', 'b'), ('c', 'c')])
+=======
+            self.assertPathRelations(
+                    tree.basis_tree(), tree,
+                    [('', ''), ('a', 'a'), ('b/', 'b/'), ('c', 'c')])
+>>>>>>> MERGE-SOURCE
         else:
             self.assertPathExists('b/c')
+<<<<<<< TREE
             self.assertPathRelations(
                     tree.basis_tree(), tree,
                     [('', ''), ('a', 'a'), ('b/', 'b'), ('b/c', 'c')])
+=======
+            self.assertPathRelations(
+                    tree.basis_tree(), tree,
+                    [('', ''), ('a', 'a'), ('b/', 'b/'), ('b/c', 'c')])
+>>>>>>> MERGE-SOURCE
         tree._validate()
 
     def test_move_onto_self(self):
@@ -239,16 +286,28 @@
         tree.commit('initial')
         os.rename('a', 'b/a')
 
+<<<<<<< TREE
         self.assertPathRelations(
                 tree.basis_tree(), tree,
                 [('', ''), ('a', 'a'), ('b/', 'b')])
+=======
+        self.assertPathRelations(
+                tree.basis_tree(), tree,
+                [('', ''), ('a', 'a'), ('b/', 'b/')])
+>>>>>>> MERGE-SOURCE
         # We don't need after=True as long as source is missing and target
         # exists.
         self.assertEqual([('a', 'b/a')],
             tree.move(['a'], 'b'))
+<<<<<<< TREE
         self.assertPathRelations(
                 tree.basis_tree(), tree,
                 [('', ''), ('b/', 'b'), ('b/a', 'a')])
+=======
+        self.assertPathRelations(
+                tree.basis_tree(), tree,
+                [('', ''), ('b/', 'b/'), ('b/a', 'a')])
+>>>>>>> MERGE-SOURCE
         tree._validate()
 
     def test_move_after_with_after(self):
@@ -258,14 +317,27 @@
         tree.commit('initial')
         os.rename('a', 'b/a')
 
+<<<<<<< TREE
         self.assertPathRelations(
                 tree.basis_tree(), tree,
                 [('', ''), ('a', 'a'), ('b/', 'b')])
+=======
+        self.assertPathRelations(
+                tree.basis_tree(), tree,
+                [('', ''), ('a', 'a'), ('b/', 'b/')])
+>>>>>>> MERGE-SOURCE
         # Passing after=True should work as well
+<<<<<<< TREE
         self.assertEqual([('a', 'b/a')], tree.move(['a'], 'b', after=True))
         self.assertPathRelations(
                 tree.basis_tree(), tree,
                 [('', ''), ('b/', 'b'), ('b/a', 'a')])
+=======
+        self.assertEqual([('a', 'b/a')], tree.move(['a'], 'b', after=True))
+        self.assertPathRelations(
+                tree.basis_tree(), tree,
+                [('', ''), ('b/', 'b/'), ('b/a', 'a')])
+>>>>>>> MERGE-SOURCE
         tree._validate()
 
     def test_move_after_no_target(self):
@@ -303,9 +375,15 @@
         # But you can pass after=True
         self.assertEqual([('a', 'b/a')],
             tree.move(['a'], 'b', after=True))
+<<<<<<< TREE
         self.assertPathRelations(
                 tree.basis_tree(), tree,
                 [('', ''), ('b/', 'b'), ('b/a', 'a')])
+=======
+        self.assertPathRelations(
+                tree.basis_tree(), tree,
+                [('', ''), ('b/', 'b/'), ('b/a', 'a')])
+>>>>>>> MERGE-SOURCE
         # But it shouldn't actually move anything
         self.assertFileEqual(a_text, 'a')
         self.assertFileEqual(ba_text, 'b/a')
@@ -317,11 +395,19 @@
         tree.add(['a', 'a/b', 'a/c', 'a/c/d', 'e'])
         tree.commit('initial')
 
+<<<<<<< TREE
         self.assertEqual([('a', 'e/a')], tree.move(['a'], 'e'))
         self.assertPathRelations(
                 tree.basis_tree(), tree,
                 [('', ''), ('e/', 'e'), ('e/a/', 'a'), ('e/a/b', 'a/b'),
                  ('e/a/c/', 'a/c'), ('e/a/c/d', 'a/c/d')])
+=======
+        self.assertEqual([('a', 'e/a')], tree.move(['a'], 'e'))
+        self.assertPathRelations(
+                tree.basis_tree(), tree,
+                [('', ''), ('e/', 'e/'), ('e/a/', 'a/'), ('e/a/b', 'a/b'),
+                 ('e/a/c/', 'a/c/'), ('e/a/c/d', 'a/c/d')])
+>>>>>>> MERGE-SOURCE
         tree._validate()
 
     def test_move_directory_into_parent(self):
@@ -335,12 +421,21 @@
 
         self.assertEqual([('c/b', 'b')],
                          tree.move(['c/b'], ''))
+<<<<<<< TREE
         self.assertPathRelations(
                 tree.basis_tree(), tree,
                 [('', ''),
                  ('b/', 'c/b'),
                  ('c/', 'c'),
                  ('b/d/', 'c/b/d')])
+=======
+        self.assertPathRelations(
+                tree.basis_tree(), tree,
+                [('', ''),
+                 ('b/', 'c/b/'),
+                 ('c/', 'c/'),
+                 ('b/d/', 'c/b/d/')])
+>>>>>>> MERGE-SOURCE
         tree._validate()
 
     def test_move_directory_with_children_in_subdir(self):
@@ -350,6 +445,7 @@
         tree.commit('initial')
 
         tree.rename_one('a/b', 'a/c/b')
+<<<<<<< TREE
         self.assertPathRelations(
             tree.basis_tree(), tree,
             [('', ''),
@@ -358,8 +454,19 @@
              ('a/c/', 'a/c'),
              ('a/c/b', 'a/b'),
              ])
+=======
+        self.assertPathRelations(
+            tree.basis_tree(), tree,
+            [('', ''),
+             ('a/', 'a/'),
+             ('d/', 'd/'),
+             ('a/c/', 'a/c/'),
+             ('a/c/b', 'a/b'),
+             ])
+>>>>>>> MERGE-SOURCE
         self.assertEqual([('a', 'd/a')],
                          tree.move(['a'], 'd'))
+<<<<<<< TREE
         self.assertPathRelations(
             tree.basis_tree(), tree,
             [('', ''),
@@ -368,6 +475,16 @@
              ('d/a/c/', 'a/c'),
              ('d/a/c/b', 'a/b'),
              ])
+=======
+        self.assertPathRelations(
+            tree.basis_tree(), tree,
+            [('', ''),
+             ('d/', 'd/'),
+             ('d/a/', 'a/'),
+             ('d/a/c/', 'a/c/'),
+             ('d/a/c/b', 'a/b'),
+             ])
+>>>>>>> MERGE-SOURCE
         tree._validate()
 
     def test_move_directory_with_deleted_children(self):
@@ -380,12 +497,21 @@
 
         self.assertEqual([('a', 'b/a')],
                          tree.move(['a'], 'b'))
+<<<<<<< TREE
         self.assertPathRelations(
             tree.basis_tree(), tree,
             [('', ''),
              ('b/', 'b'),
              ('b/a/', 'a'),
              ('b/a/c', 'a/c')])
+=======
+        self.assertPathRelations(
+            tree.basis_tree(), tree,
+            [('', ''),
+             ('b/', 'b/'),
+             ('b/a/', 'a/'),
+             ('b/a/c', 'a/c')])
+>>>>>>> MERGE-SOURCE
         tree._validate()
 
     def test_move_directory_with_new_children(self):
@@ -398,6 +524,7 @@
         tree.add(['a/b', 'a/d'])
 
         self.assertEqual([('a', 'b/a')], tree.move(['a'], 'b'))
+<<<<<<< TREE
         self.assertPathRelations(
                 tree.basis_tree(), tree,
                 [('', ''),
@@ -407,6 +534,17 @@
                  ('b/a/c', 'a/c'),
                  ('b/a/d', None),
                  ])
+=======
+        self.assertPathRelations(
+                tree.basis_tree(), tree,
+                [('', ''),
+                 ('b/', 'b/'),
+                 ('b/a/', 'a/'),
+                 ('b/a/b', None),
+                 ('b/a/c', 'a/c'),
+                 ('b/a/d', None),
+                 ])
+>>>>>>> MERGE-SOURCE
         tree._validate()
 
     def test_move_directory_with_moved_children(self):
@@ -417,6 +555,7 @@
 
         self.assertEqual([('a/b', 'b')],
                          tree.move(['a/b'], ''))
+<<<<<<< TREE
         self.assertPathRelations(
             tree.basis_tree(), tree,
             [('', ''),
@@ -426,8 +565,20 @@
              ('e/', 'e'),
              ('a/c', 'a/c'),
              ])
+=======
+        self.assertPathRelations(
+            tree.basis_tree(), tree,
+            [('', ''),
+             ('a/', 'a/'),
+             ('b', 'a/b'),
+             ('d', 'd'),
+             ('e/', 'e/'),
+             ('a/c', 'a/c'),
+             ])
+>>>>>>> MERGE-SOURCE
         self.assertEqual([('d', 'a/d')],
                          tree.move(['d'], 'a'))
+<<<<<<< TREE
         self.assertPathRelations(
             tree.basis_tree(), tree,
             [('', ''),
@@ -437,8 +588,20 @@
              ('a/c', 'a/c'),
              ('a/d', 'd'),
              ])
+=======
+        self.assertPathRelations(
+            tree.basis_tree(), tree,
+            [('', ''),
+             ('a/', 'a/'),
+             ('b', 'a/b'),
+             ('e/', 'e/'),
+             ('a/c', 'a/c'),
+             ('a/d', 'd'),
+             ])
+>>>>>>> MERGE-SOURCE
         self.assertEqual([('a', 'e/a')],
                          tree.move(['a'], 'e'))
+<<<<<<< TREE
         self.assertPathRelations(
             tree.basis_tree(), tree,
             [('', ''),
@@ -448,6 +611,17 @@
              ('e/a/c', 'a/c'),
              ('e/a/d', 'd'),
              ])
+=======
+        self.assertPathRelations(
+            tree.basis_tree(), tree,
+            [('', ''),
+             ('b', 'a/b'),
+             ('e/', 'e/'),
+             ('e/a/', 'a/'),
+             ('e/a/c', 'a/c'),
+             ('e/a/d', 'd'),
+             ])
+>>>>>>> MERGE-SOURCE
         tree._validate()
 
     def test_move_directory_with_renamed_child(self):
@@ -457,6 +631,7 @@
         tree.commit('initial')
 
         tree.rename_one('a/b', 'a/d')
+<<<<<<< TREE
         self.assertPathRelations(
             tree.basis_tree(), tree,
             [('', ''),
@@ -465,8 +640,19 @@
              ('a/c', 'a/c'),
              ('a/d', 'a/b')])
 
+=======
+        self.assertPathRelations(
+            tree.basis_tree(), tree,
+            [('', ''),
+             ('a/', 'a/'),
+             ('d/', 'd/'),
+             ('a/c', 'a/c'),
+             ('a/d', 'a/b')])
+
+>>>>>>> MERGE-SOURCE
         self.assertEqual([('a', 'd/a')],
                          tree.move(['a'], 'd'))
+<<<<<<< TREE
         self.assertPathRelations(
             tree.basis_tree(), tree,
             [('', ''),
@@ -474,6 +660,15 @@
              ('d/a/', 'a'),
              ('d/a/c', 'a/c'),
              ('d/a/d', 'a/b')])
+=======
+        self.assertPathRelations(
+            tree.basis_tree(), tree,
+            [('', ''),
+             ('d/', 'd/'),
+             ('d/a/', 'a/'),
+             ('d/a/c', 'a/c'),
+             ('d/a/d', 'a/b')])
+>>>>>>> MERGE-SOURCE
         tree._validate()
 
     def test_move_directory_with_swapped_children(self):
@@ -485,6 +680,7 @@
         tree.rename_one('a/b', 'a/bb')
         tree.rename_one('a/d', 'a/b')
         tree.rename_one('a/bb', 'a/d')
+<<<<<<< TREE
         self.assertPathRelations(
                 tree.basis_tree(), tree,
                 [('', ''),
@@ -493,8 +689,19 @@
                  ('a/b', 'a/d'),
                  ('a/c', 'a/c'),
                  ('a/d', 'a/b')])
+=======
+        self.assertPathRelations(
+                tree.basis_tree(), tree,
+                [('', ''),
+                 ('a/', 'a/'),
+                 ('e/', 'e/'),
+                 ('a/b', 'a/d'),
+                 ('a/c', 'a/c'),
+                 ('a/d', 'a/b')])
+>>>>>>> MERGE-SOURCE
         self.assertEqual([('a', 'e/a')],
                          tree.move(['a'], 'e'))
+<<<<<<< TREE
         self.assertPathRelations(
                 tree.basis_tree(), tree,
                 [('', ''),
@@ -503,6 +710,16 @@
                  ('e/a/b', 'a/d'),
                  ('e/a/c', 'a/c'),
                  ('e/a/d', 'a/b')])
+=======
+        self.assertPathRelations(
+                tree.basis_tree(), tree,
+                [('', ''),
+                 ('e/', 'e/'),
+                 ('e/a/', 'a/'),
+                 ('e/a/b', 'a/d'),
+                 ('e/a/c', 'a/c'),
+                 ('e/a/d', 'a/b')])
+>>>>>>> MERGE-SOURCE
         tree._validate()
 
     def test_move_moved(self):
@@ -514,14 +731,27 @@
 
         self.assertEqual([('a/b', 'c/b')],
             tree.move(['a/b'], 'c'))
+<<<<<<< TREE
         self.assertPathRelations(
             tree.basis_tree(), tree,
             [('', ''), ('a/', 'a'), ('c/', 'c'), ('c/b', 'a/b')])
+=======
+        self.assertPathRelations(
+            tree.basis_tree(), tree,
+            [('', ''), ('a/', 'a/'), ('c/', 'c/'), ('c/b', 'a/b')])
+>>>>>>> MERGE-SOURCE
 
+<<<<<<< TREE
         self.assertEqual([('c/b', 'b')], tree.move(['c/b'], ''))
         self.assertPathRelations(
             tree.basis_tree(), tree,
             [('', ''), ('a/', 'a'), ('b', 'a/b'), ('c/', 'c')])
+=======
+        self.assertEqual([('c/b', 'b')], tree.move(['c/b'], ''))
+        self.assertPathRelations(
+            tree.basis_tree(), tree,
+            [('', ''), ('a/', 'a/'), ('b', 'a/b'), ('c/', 'c/')])
+>>>>>>> MERGE-SOURCE
         tree._validate()
 
     def test_move_to_unversioned_non_ascii_dir(self):

=== modified file 'breezy/tests/per_workingtree/test_nested_specifics.py'
--- breezy/tests/per_workingtree/test_nested_specifics.py	2018-02-16 19:38:39 +0000
+++ breezy/tests/per_workingtree/test_nested_specifics.py	2018-03-24 17:11:56 +0000
@@ -79,5 +79,5 @@
 
     def test_iter_entries_by_dir_autodetects_subtree(self):
         tree = self.prepare_with_subtree()
-        path, ie = next(tree.iter_entries_by_dir(['subtree-id']))
+        path, ie = next(tree.iter_entries_by_dir(specific_files=['subtree']))
         self.assertEqual('tree-reference', ie.kind)

=== modified file 'breezy/tests/per_workingtree/test_paths2ids.py'
--- breezy/tests/per_workingtree/test_paths2ids.py	2018-02-03 13:39:29 +0000
+++ breezy/tests/per_workingtree/test_paths2ids.py	2018-03-24 17:11:56 +0000
@@ -22,6 +22,7 @@
 """
 
 from breezy import errors
+from breezy.bzr.inventorytree import InventoryTree
 from breezy.tests import (
     features,
     TestNotApplicable,
@@ -62,16 +63,30 @@
 
     def test_paths_none_result_none(self):
         tree = self.make_branch_and_tree('tree')
+        if not isinstance(tree, InventoryTree):
+            raise TestNotApplicable(
+                "test not applicable on non-inventory tests")
+
         tree.lock_read()
         self.assertEqual(None, tree.paths2ids(None))
         tree.unlock()
 
     def test_find_single_root(self):
         tree = self.make_branch_and_tree('tree')
+        if not isinstance(tree, InventoryTree):
+            raise TestNotApplicable(
+                "test not applicable on non-inventory tests")
+
+
         self.assertExpectedIds([tree.path2id('')], tree, [''])
 
     def test_find_tree_and_clone_roots(self):
         tree = self.make_branch_and_tree('tree')
+        if not isinstance(tree, InventoryTree):
+            raise TestNotApplicable(
+                "test not applicable on non-inventory tests")
+
+
         clone = tree.controldir.clone('clone').open_workingtree()
         clone.lock_tree_write()
         clone_root_id = 'new-id'
@@ -136,6 +151,11 @@
           new-child because its under dir in new.
         """
         tree = self.make_branch_and_tree('tree')
+        if not isinstance(tree, InventoryTree):
+            raise TestNotApplicable(
+                "test not applicable on non-inventory tests")
+
+
         self.build_tree(
             ['tree/dir/', 'tree/dir/child-moves', 'tree/dir/child-stays',
              'tree/dir/child-goes'])
@@ -161,6 +181,11 @@
 
     def test_unversioned_one_tree(self):
         tree = self.make_branch_and_tree('tree')
+        if not isinstance(tree, InventoryTree):
+            raise TestNotApplicable(
+                "test not applicable on non-inventory tests")
+
+
         self.build_tree(['tree/unversioned'])
         self.assertExpectedIds([], tree, ['unversioned'], require_versioned=False)
         tree.lock_read()
@@ -172,6 +197,10 @@
         # should not raise an error: it must be unversioned in *all* trees to
         # error.
         tree = self.make_branch_and_tree('tree')
+        if not isinstance(tree, InventoryTree):
+            raise TestNotApplicable(
+                "test not applicable on non-inventory tests")
+
         if not tree.supports_setting_file_ids():
             raise TestNotApplicable('tree does not support setting file ids')
         tree.commit('make basis')
@@ -185,6 +214,10 @@
         # should not raise an error: it must be unversioned in *all* trees to
         # error.
         tree = self.make_branch_and_tree('tree')
+        if not isinstance(tree, InventoryTree):
+            raise TestNotApplicable(
+                "test not applicable on non-inventory tests")
+
         tree.commit('make basis')
         basis = tree.basis_tree()
         self.assertExpectedIds([], tree, ['unversioned'], [basis],
@@ -201,6 +234,10 @@
     def test_unversioned_non_ascii_one_tree(self):
         self.requireFeature(features.UnicodeFilenameFeature)
         tree = self.make_branch_and_tree('.')
+        if not isinstance(tree, InventoryTree):
+            raise TestNotApplicable(
+                "test not applicable on non-inventory tests")
+
         self.build_tree([u"\xa7"])
         self.assertExpectedIds([], tree, [u"\xa7"], require_versioned=False)
         self.addCleanup(tree.lock_read().unlock)

=== modified file 'breezy/tests/per_workingtree/test_pull.py'
--- breezy/tests/per_workingtree/test_pull.py	2018-01-12 08:52:43 +0000
+++ breezy/tests/per_workingtree/test_pull.py	2018-03-24 17:11:56 +0000
@@ -103,7 +103,7 @@
         trunk = self.make_branch_deleting_dir('trunk')
         work = trunk.controldir.sprout('work', revision_id='2').open_workingtree()
         work.branch.get_config_stack().set(
-            'bzr.transform.orphan_policy', 'move')
+            'transform.orphan_policy', 'move')
         # Add some unversioned files in dir
         self.build_tree(['work/dir/foo',
                          'work/dir/subdir/',

=== modified file 'breezy/tests/per_workingtree/test_rename_one.py'
--- breezy/tests/per_workingtree/test_rename_one.py	2018-03-12 05:18:13 +0000
+++ breezy/tests/per_workingtree/test_rename_one.py	2018-03-24 17:11:56 +0000
@@ -82,9 +82,15 @@
 
         a_contents = tree.get_file_text('a')
         tree.rename_one('a', 'foo')
+<<<<<<< TREE
         self.assertPathRelations(
                 tree.basis_tree(), tree,
                 [('', ''), ('b/', 'b'), ('foo', 'a')])
+=======
+        self.assertPathRelations(
+                tree.basis_tree(), tree,
+                [('', ''), ('b/', 'b/'), ('foo', 'a')])
+>>>>>>> MERGE-SOURCE
         self.assertPathDoesNotExist('a')
         self.assertFileEqual(a_contents, 'foo')
 
@@ -96,9 +102,15 @@
 
         a_contents = tree.get_file_text('a')
         tree.rename_one('a', 'b/foo')
+<<<<<<< TREE
         self.assertPathRelations(
                 tree.basis_tree(), tree,
                 [('', ''), ('b/', 'b'), ('b/foo', 'a')])
+=======
+        self.assertPathRelations(
+                tree.basis_tree(), tree,
+                [('', ''), ('b/', 'b/'), ('b/foo', 'a')])
+>>>>>>> MERGE-SOURCE
         self.assertPathDoesNotExist('tree/a')
         self.assertFileEqual(a_contents, 'tree/b/foo')
 
@@ -107,14 +119,27 @@
         self.build_tree(['a', 'b/', 'b/c'])
         tree.add(['a', 'b', 'b/c'])
         tree.commit('initial')
+<<<<<<< TREE
         self.assertPathRelations(
                 tree.basis_tree(), tree,
                 [('', ''), ('a', 'a'), ('b/', 'b'), ('b/c', 'b/c')])
         a_contents = tree.get_file_text('a')
+=======
+        self.assertPathRelations(
+                tree.basis_tree(), tree,
+                [('', ''), ('a', 'a'), ('b/', 'b/'), ('b/c', 'b/c')])
+        a_contents = tree.get_file_text('a')
+>>>>>>> MERGE-SOURCE
         tree.rename_one('a', 'b/d')
+<<<<<<< TREE
         self.assertPathRelations(
                 tree.basis_tree(), tree,
                 [('', ''), ('b/', 'b'), ('b/c', 'b/c'), ('b/d', 'a')])
+=======
+        self.assertPathRelations(
+                tree.basis_tree(), tree,
+                [('', ''), ('b/', 'b/'), ('b/c', 'b/c'), ('b/d', 'a')])
+>>>>>>> MERGE-SOURCE
         self.assertPathDoesNotExist('a')
         self.assertFileEqual(a_contents, 'b/d')
 
@@ -125,9 +150,15 @@
         tree.commit('initial')
         c_contents = tree.get_file_text('b/c')
         tree.rename_one('b/c', 'd')
+<<<<<<< TREE
         self.assertPathRelations(
                 tree.basis_tree(), tree,
                 [('', ''), ('a', 'a'), ('b/', 'b'), ('d', 'b/c')])
+=======
+        self.assertPathRelations(
+                tree.basis_tree(), tree,
+                [('', ''), ('a', 'a'), ('b/', 'b/'), ('d', 'b/c')])
+>>>>>>> MERGE-SOURCE
         self.assertPathDoesNotExist('b/c')
         self.assertFileEqual(c_contents, 'd')
 
@@ -139,9 +170,15 @@
         # Target already exists
         self.assertRaises(errors.RenameFailedFilesExist,
                           tree.rename_one, 'a', 'b/a')
+<<<<<<< TREE
         self.assertPathRelations(
                 tree.basis_tree(), tree,
                 [('', ''), ('a', 'a'), ('b/', 'b'), ('c', 'c')])
+=======
+        self.assertPathRelations(
+                tree.basis_tree(), tree,
+                [('', ''), ('a', 'a'), ('b/', 'b/'), ('c', 'c')])
+>>>>>>> MERGE-SOURCE
 
     def test_rename_one_onto_existing(self):
         tree = self.make_branch_and_tree('.')
@@ -177,16 +214,29 @@
         tree.commit('initial')
         os.rename('a', 'b/foo')
 
+<<<<<<< TREE
         self.assertPathRelations(
                 tree.basis_tree(), tree,
                 [('', ''), ('a', 'a'), ('b/', 'b')])
 
+=======
+        self.assertPathRelations(
+                tree.basis_tree(), tree,
+                [('', ''), ('a', 'a'), ('b/', 'b/')])
+
+>>>>>>> MERGE-SOURCE
         # We don't need after=True as long as source is missing and target
         # exists.
         tree.rename_one('a', 'b/foo')
+<<<<<<< TREE
         self.assertPathRelations(
                 tree.basis_tree(), tree,
                 [('', ''), ('b/', 'b'), ('b/foo', 'a')])
+=======
+        self.assertPathRelations(
+                tree.basis_tree(), tree,
+                [('', ''), ('b/', 'b/'), ('b/foo', 'a')])
+>>>>>>> MERGE-SOURCE
 
     def test_rename_one_after_with_after(self):
         tree = self.make_branch_and_tree('.')
@@ -196,16 +246,26 @@
         os.rename('a', 'b/foo')
 
         if tree.has_versioned_directories():
+<<<<<<< TREE
             self.assertPathRelations(tree.basis_tree(), tree,
                     [('', ''), ('a', 'a'), ('b/', 'b')])
+=======
+            self.assertPathRelations(tree.basis_tree(), tree,
+                    [('', ''), ('a', 'a'), ('b/', 'b/')])
+>>>>>>> MERGE-SOURCE
         else:
             self.assertPathRelations(tree.basis_tree(), tree,
                     [('', ''), ('a', 'a')])
 
         # Passing after=True should work as well
         tree.rename_one('a', 'b/foo', after=True)
+<<<<<<< TREE
         self.assertPathRelations(tree.basis_tree(), tree,
                 [('', ''), ('b/', 'b'), ('b/foo', 'a')])
+=======
+        self.assertPathRelations(tree.basis_tree(), tree,
+                [('', ''), ('b/', 'b/'), ('b/foo', 'a')])
+>>>>>>> MERGE-SOURCE
 
     def test_rename_one_after_dest_versioned(self):
         tree = self.make_branch_and_tree('.')
@@ -266,16 +326,29 @@
         os.rename('a', 'b/foo')
         tree.remove(['a'])
 
+<<<<<<< TREE
         self.assertPathRelations(
                 tree.basis_tree(), tree,
                 [('', ''), ('b/', 'b')])
 
+=======
+        self.assertPathRelations(
+                tree.basis_tree(), tree,
+                [('', ''), ('b/', 'b/')])
+
+>>>>>>> MERGE-SOURCE
         # We don't need after=True as long as source is missing and target
         # exists.
         tree.rename_one('a', 'b/foo')
+<<<<<<< TREE
         self.assertPathRelations(
                 tree.basis_tree(), tree,
                 [('', ''), ('b/', 'b'), ('b/foo', 'a')])
+=======
+        self.assertPathRelations(
+                tree.basis_tree(), tree,
+                [('', ''), ('b/', 'b/'), ('b/foo', 'a')])
+>>>>>>> MERGE-SOURCE
 
     def test_rename_one_after_no_target(self):
         tree = self.make_branch_and_tree('.')
@@ -287,9 +360,15 @@
         # exception
         self.assertRaises(errors.BzrMoveFailedError,
                           tree.rename_one, 'a', 'b/foo', after=True)
+<<<<<<< TREE
         self.assertPathRelations(
                 tree.basis_tree(), tree,
                 [('', ''), ('a', 'a'), ('b/', 'b')])
+=======
+        self.assertPathRelations(
+                tree.basis_tree(), tree,
+                [('', ''), ('a', 'a'), ('b/', 'b/')])
+>>>>>>> MERGE-SOURCE
 
     def test_rename_one_after_source_and_dest(self):
         tree = self.make_branch_and_tree('.')
@@ -304,21 +383,39 @@
         with open('b/foo', 'r') as foo_file:
             foo_text = foo_file.read()
 
+<<<<<<< TREE
         self.assertPathRelations(
                 tree.basis_tree(), tree,
                 [('', ''), ('a', 'a'), ('b/', 'b')])
+=======
+        self.assertPathRelations(
+                tree.basis_tree(), tree,
+                [('', ''), ('a', 'a'), ('b/', 'b/')])
+>>>>>>> MERGE-SOURCE
         self.assertRaises(errors.RenameFailedFilesExist,
                           tree.rename_one, 'a', 'b/foo', after=False)
+<<<<<<< TREE
         self.assertPathRelations(
                 tree.basis_tree(), tree,
                 [('', ''), ('a', 'a'), ('b/', 'b')])
+=======
+        self.assertPathRelations(
+                tree.basis_tree(), tree,
+                [('', ''), ('a', 'a'), ('b/', 'b/')])
+>>>>>>> MERGE-SOURCE
         self.assertFileEqual(a_text, 'a')
         self.assertFileEqual(foo_text, 'b/foo')
         # But you can pass after=True
         tree.rename_one('a', 'b/foo', after=True)
+<<<<<<< TREE
         self.assertPathRelations(
                 tree.basis_tree(), tree,
                 [('', ''), ('b/', 'b'), ('b/foo', 'a')])
+=======
+        self.assertPathRelations(
+                tree.basis_tree(), tree,
+                [('', ''), ('b/', 'b/'), ('b/foo', 'a')])
+>>>>>>> MERGE-SOURCE
         # But it shouldn't actually move anything
         self.assertFileEqual(a_text, 'a')
         self.assertFileEqual(foo_text, 'b/foo')
@@ -330,11 +427,19 @@
         tree.commit('initial')
 
         tree.rename_one('a', 'e/f')
+<<<<<<< TREE
         self.assertPathRelations(
                 tree.basis_tree(), tree,
                 [('', ''), ('e/', 'e'), ('e/f/', 'a'),
                  ('e/f/b', 'a/b'), ('e/f/c/', 'a/c'),
                  ('e/f/c/d', 'a/c/d')])
+=======
+        self.assertPathRelations(
+                tree.basis_tree(), tree,
+                [('', ''), ('e/', 'e/'), ('e/f/', 'a/'),
+                 ('e/f/b', 'a/b'), ('e/f/c/', 'a/c/'),
+                 ('e/f/c/d', 'a/c/d')])
+>>>>>>> MERGE-SOURCE
 
     def test_rename_one_moved(self):
         """Moving a moved entry works as expected."""
@@ -345,14 +450,26 @@
         root_id = tree.get_root_id()
 
         tree.rename_one('a/b', 'c/foo')
+<<<<<<< TREE
         self.assertPathRelations(
                 tree.basis_tree(), tree,
                 [('', ''), ('a/', 'a'), ('c/', 'c'), ('c/foo', 'a/b')])
+=======
+        self.assertPathRelations(
+                tree.basis_tree(), tree,
+                [('', ''), ('a/', 'a/'), ('c/', 'c/'), ('c/foo', 'a/b')])
+>>>>>>> MERGE-SOURCE
 
         tree.rename_one('c/foo', 'bar')
+<<<<<<< TREE
         self.assertPathRelations(
                 tree.basis_tree(), tree,
                 [('', ''), ('a/', 'a'), ('bar', 'a/b'), ('c/', 'c')])
+=======
+        self.assertPathRelations(
+                tree.basis_tree(), tree,
+                [('', ''), ('a/', 'a/'), ('bar', 'a/b'), ('c/', 'c/')])
+>>>>>>> MERGE-SOURCE
 
     def test_rename_to_denormalised_fails(self):
         if osutils.normalizes_filenames():

=== modified file 'breezy/tests/per_workingtree/test_revision_tree.py'
--- breezy/tests/per_workingtree/test_revision_tree.py	2018-03-02 16:32:39 +0000
+++ breezy/tests/per_workingtree/test_revision_tree.py	2018-03-24 17:11:56 +0000
@@ -123,7 +123,7 @@
         basis = tree.revision_tree(parents[0])
         basis.lock_read()
         self.addCleanup(basis.unlock)
-        self.assertRaises(errors.NoSuchId, basis.kind, 'a')
+        self.assertRaises(errors.NoSuchFile, basis.kind, 'a')
         self.assertEqual(['directory', 'file'],
                          [basis.kind('b'), basis.kind('b/c')])
         try:
@@ -134,6 +134,6 @@
                 % type(tree))
         other.lock_read()
         self.addCleanup(other.unlock)
-        self.assertRaises(errors.NoSuchId, other.kind, 'b')
-        self.assertRaises(errors.NoSuchId, other.kind, 'c')
+        self.assertRaises(errors.NoSuchFile, other.kind, 'b')
+        self.assertRaises(errors.NoSuchFile, other.kind, 'c')
         self.assertEqual('file', other.kind('a'))

=== modified file 'breezy/tests/per_workingtree/test_workingtree.py'
--- breezy/tests/per_workingtree/test_workingtree.py	2018-03-09 00:05:39 +0000
+++ breezy/tests/per_workingtree/test_workingtree.py	2018-03-24 17:11:56 +0000
@@ -711,17 +711,17 @@
         with tree.lock_write():
             tree.add(['somefile'])
             d = {tree.path2id('somefile'): osutils.sha_string('hello')}
-            try:
+            if tree.supports_merge_modified():
                 tree.set_merge_modified(d)
-            except errors.UnsupportedOperation:
+                mm = tree.merge_modified()
+                self.assertEqual(mm, d)
+            else:
+                self.assertRaises(
+                    errors.UnsupportedOperation,
+                    tree.set_merge_modified, d)
                 mm = tree.merge_modified()
                 self.assertEqual(mm, {})
-                supports_merge_modified = False
-            else:
-                mm = tree.merge_modified()
-                self.assertEqual(mm, d)
-                supports_merge_modified = True
-        if supports_merge_modified:
+        if tree.supports_merge_modified():
             mm = tree.merge_modified()
             self.assertEqual(mm, d)
         else:

=== modified file 'breezy/tests/test_bundle.py'
--- breezy/tests/test_bundle.py	2018-02-15 19:38:33 +0000
+++ breezy/tests/test_bundle.py	2018-03-24 17:11:56 +0000
@@ -663,7 +663,7 @@
                 , 'sub/sub'
                 ])
         tt = TreeTransform(self.tree1)
-        trans_id = tt.trans_id_tree_file_id('exe-1')
+        trans_id = tt.trans_id_tree_path('executable')
         tt.set_executability(False, trans_id)
         tt.apply()
         self.tree1.commit('removed', rev_id='a@cset-0-3')
@@ -731,7 +731,7 @@
             self.assertEqual(link_target, bund_tree.get_symlink_target(link_name))
 
         tt = TreeTransform(self.tree1)
-        trans_id = tt.trans_id_tree_file_id(link_id)
+        trans_id = tt.trans_id_tree_path(link_name)
         tt.adjust_path('link2', tt.root, trans_id)
         tt.delete_contents(trans_id)
         tt.create_symlink(new_link_target, trans_id)
@@ -745,7 +745,7 @@
                              bund_tree.get_symlink_target('link2'))
 
         tt = TreeTransform(self.tree1)
-        trans_id = tt.trans_id_tree_file_id(link_id)
+        trans_id = tt.trans_id_tree_path('link2')
         tt.delete_contents(trans_id)
         tt.create_symlink('jupiter', trans_id)
         tt.apply()
@@ -753,7 +753,7 @@
         bundle = self.get_valid_bundle('l@cset-0-2', 'l@cset-0-3')
 
         tt = TreeTransform(self.tree1)
-        trans_id = tt.trans_id_tree_file_id(link_id)
+        trans_id = tt.trans_id_tree_path('link2')
         tt.delete_contents(trans_id)
         tt.apply()
         self.tree1.commit('Delete symlink', rev_id='l@cset-0-4')
@@ -783,7 +783,7 @@
 
         # Delete
         tt = TreeTransform(self.tree1)
-        trans_id = tt.trans_id_tree_file_id('binary-1')
+        trans_id = tt.trans_id_tree_path('file')
         tt.delete_contents(trans_id)
         tt.apply()
         self.tree1.commit('delete binary', rev_id='b@cset-0-2')
@@ -791,7 +791,7 @@
 
         # Rename & modify
         tt = TreeTransform(self.tree1)
-        trans_id = tt.trans_id_tree_file_id('binary-2')
+        trans_id = tt.trans_id_tree_path('file2')
         tt.adjust_path('file3', tt.root, trans_id)
         tt.delete_contents(trans_id)
         tt.create_file('file\rcontents\x00\n\x00', trans_id)
@@ -801,7 +801,7 @@
 
         # Modify
         tt = TreeTransform(self.tree1)
-        trans_id = tt.trans_id_tree_file_id('binary-2')
+        trans_id = tt.trans_id_tree_path('file3')
         tt.delete_contents(trans_id)
         tt.create_file('\x00file\rcontents', trans_id)
         tt.apply()
@@ -820,7 +820,7 @@
         self.tree1.commit('create file', rev_id='a@lmod-0-1')
 
         tt = TreeTransform(self.tree1)
-        trans_id = tt.trans_id_tree_file_id('file')
+        trans_id = tt.trans_id_tree_path('file')
         tt.delete_contents(trans_id)
         tt.create_file('file2', trans_id)
         tt.apply()
@@ -828,7 +828,7 @@
 
         other = self.get_checkout('a@lmod-0-1')
         tt = TreeTransform(other)
-        trans_id = tt.trans_id_tree_file_id('file')
+        trans_id = tt.trans_id_tree_path('file2')
         tt.delete_contents(trans_id)
         tt.create_file('file2', trans_id)
         tt.apply()

=== modified file 'breezy/tests/test_bzrdir.py'
--- breezy/tests/test_bzrdir.py	2017-11-12 20:07:32 +0000
+++ breezy/tests/test_bzrdir.py	2018-03-24 17:11:56 +0000
@@ -864,7 +864,7 @@
         tree.commit('Initial commit')
         # The following line force the orhaning to reveal bug #634470
         tree.branch.get_config_stack().set(
-            'bzr.transform.orphan_policy', 'move')
+            'transform.orphan_policy', 'move')
         tree.controldir.destroy_workingtree()
         # FIXME: subtree/.bzr is left here which allows the test to pass (or
         # fail :-( ) -- vila 20100909

=== modified file 'breezy/tests/test_matchers.py'
--- breezy/tests/test_matchers.py	2018-03-12 02:24:39 +0000
+++ breezy/tests/test_matchers.py	2018-03-24 17:11:56 +0000
@@ -151,6 +151,7 @@
             set(mismatch.describe().split(" != ")))
 
 
+<<<<<<< TREE
 class TestHasPathRelations(TestCaseWithTransport):
 
     def test__str__(self):
@@ -176,6 +177,33 @@
         self.assertIsNot(None, mismatch)
 
 
+=======
+class TestHasPathRelations(TestCaseWithTransport):
+
+    def test__str__(self):
+        t = self.make_branch_and_tree('.')
+        matcher = HasPathRelations(t, [("a", "b")])
+        self.assertEqual("HasPathRelations(%r, [('a', 'b')])" % t, str(matcher))
+
+    def test_match(self):
+        t = self.make_branch_and_tree('.')
+        self.build_tree(['a', 'b/', 'b/c'])
+        t.add(['a', 'b', 'b/c'])
+        self.assertThat(t, HasPathRelations(t,
+            [('', ''),
+             ('a', 'a'),
+             ('b/', 'b/'),
+             ('b/c', 'b/c')]))
+
+    def test_mismatch(self):
+        t = self.make_branch_and_tree('.')
+        self.build_tree(['a', 'b/', 'b/c'])
+        t.add(['a', 'b', 'b/c'])
+        mismatch = HasPathRelations(t, [('a', 'a')]).match(t)
+        self.assertIsNot(None, mismatch)
+
+
+>>>>>>> MERGE-SOURCE
 class TestContainsNoVfsCalls(TestCase):
 
     def _make_call(self, method, args):

=== modified file 'breezy/tests/test_merge.py'
--- breezy/tests/test_merge.py	2018-02-16 19:38:39 +0000
+++ breezy/tests/test_merge.py	2018-03-24 17:11:56 +0000
@@ -1265,8 +1265,7 @@
         builder.build_snapshot(['B-id', 'C-id'], [], revision_id='D-id')
         return builder
 
-    def make_Merger(self, builder, other_revision_id,
-                    interesting_files=None, interesting_ids=None):
+    def make_Merger(self, builder, other_revision_id, interesting_files=None):
         """Make a Merger object from a branch builder"""
         mem_tree = memorytree.MemoryTree.create_on_branch(builder.get_branch())
         mem_tree.lock_write()
@@ -1274,8 +1273,6 @@
         merger = _mod_merge.Merger.from_revision_ids(
             mem_tree, other_revision_id)
         merger.set_interesting_files(interesting_files)
-        # It seems there is no matching function for set_interesting_ids
-        merger.interesting_ids = interesting_ids
         merger.merge_type = _mod_merge.Merge3Merger
         return merger
 
@@ -1400,10 +1397,9 @@
 class TestMergerEntriesLCA(TestMergerBase):
 
     def make_merge_obj(self, builder, other_revision_id,
-                       interesting_files=None, interesting_ids=None):
+                       interesting_files=None):
         merger = self.make_Merger(builder, other_revision_id,
-            interesting_files=interesting_files,
-            interesting_ids=interesting_ids)
+            interesting_files=interesting_files)
         return merger.make_merger()
 
     def test_simple(self):
@@ -1435,6 +1431,7 @@
         # BASE, lca1, lca2, OTHER, THIS
         root_id = 'a-root-id'
         self.assertEqual([('a-id', True,
+                           ((u'a', [u'a', u'a']), u'a', u'a'),
                            ((root_id, [root_id, root_id]), root_id, root_id),
                            ((u'a', [u'a', u'a']), u'a', u'a'),
                            ((False, [False, False]), False, False)),
@@ -1480,6 +1477,7 @@
         entries = list(merge_obj._entries_lca())
         root_id = 'a-root-id'
         self.assertEqual([('bar-id', True,
+                           ((None, [u'bar', u'bar']), u'bar', u'bar'),
                            ((None, [root_id, root_id]), root_id, root_id),
                            ((None, [u'bar', u'bar']), u'bar', u'bar'),
                            ((None, [False, False]), False, False)),
@@ -1512,6 +1510,7 @@
         entries = list(merge_obj._entries_lca())
         root_id = 'a-root-id'
         self.assertEqual([('a-id', True,
+                           ((u'a', [u'a', u'a']), u'a', None),
                            ((root_id, [root_id, root_id]), root_id, None),
                            ((u'a', [u'a', u'a']), u'a', None),
                            ((False, [False, False]), False, None)),
@@ -1562,6 +1561,7 @@
         entries = list(merge_obj._entries_lca())
         root_id = 'a-root-id'
         self.assertEqual([('a-id', True,
+                           ((u'a', [u'a', u'a']), None, u'a'),
                            ((root_id, [root_id, root_id]), None, root_id),
                            ((u'a', [u'a', u'a']), None, u'a'),
                            ((False, [False, False]), None, False)),
@@ -1627,6 +1627,7 @@
         entries = list(merge_obj._entries_lca())
         root_id = 'a-root-id'
         self.assertEqual([('foo-id', True,
+                           ((u'foo', [u'foo', None]), None, u'foo'),
                            ((root_id, [root_id, None]), None, root_id),
                            ((u'foo', [u'foo', None]), None, 'foo'),
                            ((False, [False, None]), None, False)),
@@ -1681,6 +1682,7 @@
         entries = list(merge_obj._entries_lca())
         root_id = 'a-root-id'
         self.assertEqual([('a-id', True,
+                           ((None, [None, None]), u'a', None),
                            ((None, [None, None]), root_id, None),
                            ((None, [None, None]), u'a', None),
                            ((None, [None, None]), False, None)),
@@ -1843,6 +1845,7 @@
         entries = list(merge_obj._entries_lca())
         root_id = 'a-root-id'
         self.assertEqual([('foo-id', True,
+                           ((u'foo', [u'foo', u'foo']), u'foo', u'foo'),
                            ((root_id, [root_id, root_id]), root_id, root_id),
                            ((u'foo', [u'foo', u'foo']), u'foo', u'foo'),
                            ((False, [False, False]), False, False)),
@@ -1880,6 +1883,7 @@
         entries = list(merge_obj._entries_lca())
         root_id = 'a-root-id'
         self.assertEqual([('foo-id', True,
+                           ((u'foo', [u'foo', u'foo']), u'foo', u'foo'),
                            ((root_id, [root_id, root_id]), root_id, root_id),
                            ((u'foo', [u'foo', u'foo']), u'foo', u'foo'),
                            ((False, [False, False]), False, False)),
@@ -1941,6 +1945,7 @@
         root_id = 'a-root-id'
         # The content was not changed, only the path
         self.assertEqual([('a-id', False,
+                           ((u'a', [u'b', u'b']), u'b', u'a'),
                            ((root_id, [root_id, root_id]), root_id, root_id),
                            ((u'a', [u'a', u'a']), u'b', u'a'),
                            ((False, [False, False]), False, False)),
@@ -1966,6 +1971,7 @@
         root_id = 'a-root-id'
         # Only the kind was changed (content)
         self.assertEqual([('a-id', True,
+                           ((u'a', [u'a', u'a']), u'a', u'a'),
                            ((root_id, [root_id, root_id]), root_id, root_id),
                            ((u'a', [u'a', u'a']), u'a', u'a'),
                            ((False, [False, False]), False, False)),
@@ -2011,6 +2017,7 @@
         entries = list(merge_obj._entries_lca())
         root_id = 'a-root-id'
         self.assertEqual([('b-id', True,
+                           ((u'b', [u'b', u'b']), u'b', u'b'),
                            ((root_id, [root_id, root_id]), root_id, root_id),
                            ((u'b', [u'b', u'b']), u'b', u'b'),
                            ((False, [False, False]), False, False)),
@@ -2038,6 +2045,7 @@
         entries = list(merge_obj._entries_lca())
         root_id = 'a-root-id'
         self.assertEqual([('b-id', True,
+                           ((u'b', [u'b', u'b']), u'b', u'c'),
                            ((root_id, [root_id, root_id]), root_id, root_id),
                            ((u'b', [u'b', u'b']), u'b', u'c'),
                            ((False, [False, False]), False, False)),
@@ -2067,6 +2075,7 @@
         entries = list(merge_obj._entries_lca())
         root_id = 'a-root-id'
         self.assertEqual([('c-id', True,
+                           ((u'c', [u'b', u'b']), u'b', u'b'),
                            ((root_id, [root_id, root_id]), root_id, root_id),
                            ((u'c', [u'b', u'b']), u'b', u'b'),
                            ((False, [False, False]), False, False)),
@@ -2094,12 +2103,13 @@
         entries = list(merge_obj._entries_lca())
         root_id = 'a-root-id'
         self.assertEqual([('b-id', True,
+                           ((u'b', [u'b', u'b']), u'b', u'b'),
                            ((root_id, [root_id, root_id]), root_id, root_id),
                            ((u'b', [u'c', u'b']), u'b', u'b'),
                            ((False, [False, False]), False, False)),
                          ], entries)
 
-    def test_interesting_ids(self):
+    def test_interesting_files(self):
         # Two files modified, but we should filter one of them
         builder = self.get_builder()
         builder.build_snapshot(None,
@@ -2114,10 +2124,11 @@
              ('modify', ('b-id', 'new-content\n'))], revision_id='E-id')
         builder.build_snapshot(['B-id', 'C-id'], [], revision_id='D-id')
         merge_obj = self.make_merge_obj(builder, 'E-id',
-                                        interesting_ids=['b-id'])
+                                        interesting_files=['b'])
         entries = list(merge_obj._entries_lca())
         root_id = 'a-root-id'
         self.assertEqual([('b-id', True,
+                           ((u'b', [u'b', u'b']), u'b', u'b'),
                            ((root_id, [root_id, root_id]), root_id, root_id),
                            ((u'b', [u'b', u'b']), u'b', u'b'),
                            ((False, [False, False]), False, False)),
@@ -2253,7 +2264,7 @@
         wt = self.get_wt_from_builder(builder)
         tt = transform.TreeTransform(wt)
         try:
-            tt.set_executability(True, tt.trans_id_tree_file_id('foo-id'))
+            tt.set_executability(True, tt.trans_id_tree_path('foo'))
             tt.apply()
         except:
             tt.finalize()
@@ -2432,6 +2443,7 @@
         entries = list(merge_obj._entries_lca())
         # No content change, just a path change
         self.assertEqual([('foo-id', False,
+                           ((u'foo', [u'blah', u'blah']), u'blah', u'barry'),
                            ((root_id, [root_id, root_id]), root_id, root_id),
                            ((u'foo', [u'barry', u'foo']), u'blah', u'barry'),
                            ((False, [False, False]), False, False)),
@@ -2536,6 +2548,7 @@
         entries = list(merge_obj._entries_lca())
         root_id = wt.path2id('')
         self.assertEqual([('foo-id', True,
+                           ((None, [u'foo', None]), u'foo', u'foo'),
                            ((None, [root_id, None]), root_id, root_id),
                            ((None, [u'foo', None]), u'foo', u'foo'),
                            ((None, [False, None]), False, False)),
@@ -2597,6 +2610,7 @@
         entries = list(merge_obj._entries_lca())
         root_id = wt.path2id('')
         self.assertEqual([('foo-id', True,
+                           ((u'foo', [u'foo', u'foo']), u'foo', u'foo'),
                            ((root_id, [root_id, root_id]), root_id, root_id),
                            ((u'foo', [u'foo', u'foo']), u'foo', u'foo'),
                            ((False, [False, False]), False, False)),
@@ -2720,10 +2734,12 @@
         entries = list(merge_obj._entries_lca())
         root_id = 'a-root-id'
         self.assertEqual([('a-id', False,
+                           ((u'a', [u'c', u'c']), u'c', u'b'),
                            ((root_id, [root_id, root_id]), root_id, root_id),
                            ((u'a', [u'a', u'b']), u'c', u'b'),
                            ((False, [False, False]), False, False)),
                           ('foo-id', True,
+                           ((u'foo', [u'foo', u'foo']), u'foo', u'foo'),
                            ((root_id, [root_id, root_id]), root_id, root_id),
                            ((u'foo', [u'foo', u'foo']), u'foo', u'foo'),
                            ((False, [False, False]), False, False)),
@@ -2838,6 +2854,7 @@
         entries = list(merge_obj._entries_lca())
         root_id = 'a-root-id'
         self.assertEqual([('sub-tree-root', False,
+                           ((u'sub', [u'alt_sub', u'alt_sub']), u'alt_sub', u'sub'),
                            ((root_id, [root_id, root_id]), root_id, root_id),
                            ((u'sub', [u'sub', u'sub']), u'alt_sub', u'sub'),
                            ((False, [False, False]), False, False)),
@@ -2882,6 +2899,7 @@
         entries = list(merge_obj._entries_lca())
         root_id = 'a-root-id'
         self.assertEqual([('sub-tree-root', False,
+                           ((u'sub', [u'alt_sub', u'alt_sub']), u'alt_sub', u'sub'),
                            ((root_id, [root_id, root_id]), root_id, root_id),
                            ((u'sub', [u'sub', u'sub']), u'alt_sub', u'sub'),
                            ((False, [False, False]), False, False)),

=== modified file 'breezy/tests/test_merge_core.py'
--- breezy/tests/test_merge_core.py	2018-03-09 19:52:32 +0000
+++ breezy/tests/test_merge_core.py	2018-03-24 17:11:56 +0000
@@ -77,8 +77,8 @@
             if option is True:
                 new_file(tt)
 
-    def merge(self, merge_type=Merge3Merger, interesting_ids=None, **kwargs):
-        merger = self.make_merger(merge_type, interesting_ids, **kwargs)
+    def merge(self, merge_type=Merge3Merger, interesting_files=None, **kwargs):
+        merger = self.make_merger(merge_type, interesting_files, **kwargs)
         merger.do_merge()
         return merger.cooked_conflicts
 
@@ -86,7 +86,7 @@
         merger = self.make_merger(Merge3Merger, None, this_revision_tree=True)
         return merger.make_preview_transform()
 
-    def make_merger(self, merge_type, interesting_ids,
+    def make_merger(self, merge_type, interesting_files,
             this_revision_tree=False, **kwargs):
         self.base_tt.apply()
         self.base.commit('base commit')
@@ -110,7 +110,7 @@
         else:
             this_tree = self.this
         merger = merge_type(this_tree, self.this, self.base, other_basis,
-                            interesting_ids=interesting_ids, do_merge=False,
+                            interesting_files=interesting_files, do_merge=False,
                             this_branch=self.this.branch, **kwargs)
         return merger
 
@@ -251,7 +251,7 @@
         builder.change_contents("1", other="text4")
         builder.add_file("2", builder.tree_root, "name2", "hello1", True)
         builder.change_contents("2", other="text4")
-        builder.merge(interesting_ids=["1"])
+        builder.merge(interesting_files=["name1"])
         self.assertEqual(builder.this.get_file("name1").read(), "text4" )
         self.assertEqual(builder.this.get_file("name2").read(), "hello1" )
         builder.cleanup()

=== modified file 'breezy/tests/test_revert.py'
--- breezy/tests/test_revert.py	2017-11-12 17:53:35 +0000
+++ breezy/tests/test_revert.py	2018-03-24 17:11:56 +0000
@@ -97,7 +97,7 @@
     def test_preserve_execute(self):
         tree = self.tree_with_executable()
         tt = transform.TreeTransform(tree)
-        newfile = tt.trans_id_tree_file_id('newfile-id')
+        newfile = tt.trans_id_tree_path('newfile')
         tt.delete_contents(newfile)
         tt.create_file('Woooorld!', newfile)
         tt.apply()
@@ -112,7 +112,7 @@
     def test_revert_executable(self):
         tree = self.tree_with_executable()
         tt = transform.TreeTransform(tree)
-        newfile = tt.trans_id_tree_file_id('newfile-id')
+        newfile = tt.trans_id_tree_path('newfile')
         tt.set_executability(False, newfile)
         tt.apply()
         tree.lock_write()

=== modified file 'breezy/tests/test_shelf.py'
--- breezy/tests/test_shelf.py	2017-12-12 01:19:18 +0000
+++ breezy/tests/test_shelf.py	2018-03-24 17:11:56 +0000
@@ -206,7 +206,7 @@
 
     def check_shelve_creation(self, creator, tree):
         self.assertRaises(StopIteration,
-                          next, tree.iter_entries_by_dir(['foo-id']))
+                          next, tree.iter_entries_by_dir(specific_files=['foo']))
         s_trans_id = creator.shelf_transform.trans_id_file_id('foo-id')
         self.assertEqual('foo-id',
                          creator.shelf_transform.final_file_id(s_trans_id))
@@ -349,7 +349,7 @@
         creator.shelve_creation('foo-id')
         creator.transform()
         self.assertRaises(StopIteration,
-                          next, tree.iter_entries_by_dir(['foo-id']))
+                          next, tree.iter_entries_by_dir(specific_files=['foo']))
         self.assertShelvedFileEqual('', creator, 'foo-id')
         s_trans_id = creator.shelf_transform.trans_id_file_id('foo-id')
         self.assertEqual('foo-id',

=== modified file 'breezy/tests/test_transform.py'
--- breezy/tests/test_transform.py	2018-03-09 19:52:32 +0000
+++ breezy/tests/test_transform.py	2018-03-24 17:11:56 +0000
@@ -453,7 +453,7 @@
         self.assertEqual(self.wt.path2id('name'), 'my_pretties')
         self.assertEqual('contents', file(self.wt.abspath('name')).read())
         transform2, root = self.get_transform()
-        oz_id = transform2.trans_id_tree_file_id('oz-id')
+        oz_id = transform2.trans_id_tree_path('oz')
         newtip = transform2.new_file('tip', oz_id, 'other', 'tip-id')
         result = transform2.find_conflicts()
         fp = FinalPaths(transform2)
@@ -467,12 +467,12 @@
         transform2.finalize()
         transform3 = TreeTransform(self.wt)
         self.addCleanup(transform3.finalize)
-        oz_id = transform3.trans_id_tree_file_id('oz-id')
+        oz_id = transform3.trans_id_tree_path('oz')
         transform3.delete_contents(oz_id)
         self.assertEqual(transform3.find_conflicts(),
                          [('missing parent', oz_id)])
         root_id = transform3.root
-        tip_id = transform3.trans_id_tree_file_id('tip-id')
+        tip_id = transform3.trans_id_tree_path('oz/tip')
         transform3.adjust_path('tip', root_id, tip_id)
         transform3.apply()
 
@@ -601,7 +601,7 @@
         start.new_directory('a', root, 'a')
         start.apply()
         transform, root = self.get_transform()
-        transform.delete_versioned(transform.trans_id_tree_file_id('a'))
+        transform.delete_versioned(transform.trans_id_tree_path('a'))
         transform.new_directory('a', root, 'a')
         transform.apply()
 
@@ -616,7 +616,7 @@
         unversion.unversion_file(parent)
         self.assertEqual(unversion.find_conflicts(),
                          [('unversioned parent', parent_id)])
-        file_id = unversion.trans_id_tree_file_id('child-id')
+        file_id = unversion.trans_id_tree_path('parent/child')
         unversion.unversion_file(file_id)
         unversion.apply()
 
@@ -635,23 +635,23 @@
         mangle_tree, root = self.get_transform()
         root = mangle_tree.root
         #swap names
-        name1 = mangle_tree.trans_id_tree_file_id('name1')
-        name2 = mangle_tree.trans_id_tree_file_id('name2')
+        name1 = mangle_tree.trans_id_tree_path('name1')
+        name2 = mangle_tree.trans_id_tree_path('name2')
         mangle_tree.adjust_path('name2', root, name1)
         mangle_tree.adjust_path('name1', root, name2)
 
         #tests for deleting parent directories
-        ddir = mangle_tree.trans_id_tree_file_id('ddir')
+        ddir = mangle_tree.trans_id_tree_path('dying_directory')
         mangle_tree.delete_contents(ddir)
-        dfile = mangle_tree.trans_id_tree_file_id('dfile')
+        dfile = mangle_tree.trans_id_tree_path('dying_directory/dying_file')
         mangle_tree.delete_versioned(dfile)
         mangle_tree.unversion_file(dfile)
-        mfile = mangle_tree.trans_id_tree_file_id('mfile')
+        mfile = mangle_tree.trans_id_tree_path('dying_directory/moving_file')
         mangle_tree.adjust_path('mfile', root, mfile)
 
         #tests for adding parent directories
         newdir = mangle_tree.new_directory('new_directory', root, 'newdir')
-        mfile2 = mangle_tree.trans_id_tree_file_id('mfile2')
+        mfile2 = mangle_tree.trans_id_tree_path('moving_file2')
         mangle_tree.adjust_path('mfile2', newdir, mfile2)
         mangle_tree.new_file('newfile', newdir, 'hello3', 'dfile')
         self.assertEqual(mangle_tree.final_file_id(mfile2), 'mfile2')
@@ -677,8 +677,8 @@
         create_tree.new_file('blackbox.py', newdir, 'hello1', 'blackbox-id')
         create_tree.apply()
         mangle_tree, root = self.get_transform()
-        selftest = mangle_tree.trans_id_tree_file_id('selftest-id')
-        blackbox = mangle_tree.trans_id_tree_file_id('blackbox-id')
+        selftest = mangle_tree.trans_id_tree_path('selftest')
+        blackbox = mangle_tree.trans_id_tree_path('selftest/blackbox.py')
         mangle_tree.adjust_path('test', root, selftest)
         mangle_tree.adjust_path('test_too_much', root, selftest)
         mangle_tree.set_executability(True, blackbox)
@@ -693,9 +693,9 @@
                              'test_too_much-id')
         create_tree.apply()
         mangle_tree, root = self.get_transform()
-        breezy = mangle_tree.trans_id_tree_file_id('breezy-id')
-        tests = mangle_tree.trans_id_tree_file_id('tests-id')
-        test_too_much = mangle_tree.trans_id_tree_file_id('test_too_much-id')
+        breezy = mangle_tree.trans_id_tree_path('breezy')
+        tests = mangle_tree.trans_id_tree_path('breezy/tests')
+        test_too_much = mangle_tree.trans_id_tree_path('breezy/tests/blackbox/test_too_much.py')
         mangle_tree.adjust_path('selftest', breezy, tests)
         mangle_tree.adjust_path('blackbox.py', tests, test_too_much)
         mangle_tree.set_executability(True, test_too_much)
@@ -708,8 +708,8 @@
                              'test_too_much-id')
         create_tree.apply()
         mangle_tree, root = self.get_transform()
-        tests = mangle_tree.trans_id_tree_file_id('tests-id')
-        test_too_much = mangle_tree.trans_id_tree_file_id('test_too_much-id')
+        tests = mangle_tree.trans_id_tree_path('tests')
+        test_too_much = mangle_tree.trans_id_tree_path('tests/test_too_much.py')
         mangle_tree.adjust_path('selftest', root, tests)
         mangle_tree.adjust_path('blackbox.py', tests, test_too_much)
         mangle_tree.set_executability(True, test_too_much)
@@ -722,11 +722,11 @@
         create_tree.new_file('name1', root, 'hello1', 'name1')
         create_tree.apply()
         delete_contents, root = self.get_transform()
-        file = delete_contents.trans_id_tree_file_id('name1')
+        file = delete_contents.trans_id_tree_path('name1')
         delete_contents.delete_contents(file)
         delete_contents.apply()
         move_id, root = self.get_transform()
-        name1 = move_id.trans_id_tree_file_id('name1')
+        name1 = move_id.trans_id_tree_path('name1')
         newdir = move_id.new_directory('dir', root, 'newdir')
         move_id.adjust_path('name2', newdir, name1)
         move_id.apply()
@@ -739,7 +739,7 @@
         create_tree.apply()
         delete_contents = TreeTransform(self.wt)
         self.addCleanup(delete_contents.finalize)
-        file = delete_contents.trans_id_tree_file_id('name1')
+        file = delete_contents.trans_id_tree_path('name1')
         delete_contents.delete_contents(file)
         delete_contents.apply()
         delete_contents.finalize()
@@ -747,7 +747,7 @@
         self.addCleanup(replace.finalize)
         name2 = replace.new_file('name2', root, 'hello2', 'name1')
         conflicts = replace.find_conflicts()
-        name1 = replace.trans_id_tree_file_id('name1')
+        name1 = replace.trans_id_tree_path('name1')
         self.assertEqual(conflicts, [('duplicate id', name1, name2)])
         resolve_conflicts(replace)
         replace.apply()
@@ -819,11 +819,11 @@
         # set up duplicate entry, duplicate id
         new_dorothy = conflicts.new_file('dorothy', root, 'dorothy',
                                          'dorothy-id')
-        old_dorothy = conflicts.trans_id_tree_file_id('dorothy-id')
-        oz = conflicts.trans_id_tree_file_id('oz-id')
+        old_dorothy = conflicts.trans_id_tree_path('dorothy')
+        oz = conflicts.trans_id_tree_path('oz')
         # set up DeletedParent parent conflict
         conflicts.delete_versioned(oz)
-        emerald = conflicts.trans_id_tree_file_id('emerald-id')
+        emerald = conflicts.trans_id_tree_path('oz/emeraldcity')
         # set up MissingParent conflict
         munchkincity = conflicts.trans_id_file_id('munchkincity-id')
         conflicts.adjust_path('munchkincity', root, munchkincity)
@@ -975,8 +975,8 @@
         create.new_directory('oz', root, 'oz-id')
         create.apply()
         cyclone, root = self.get_transform()
-        oz = cyclone.trans_id_tree_file_id('oz-id')
-        house = cyclone.trans_id_tree_file_id('house-id')
+        oz = cyclone.trans_id_tree_path('oz')
+        house = cyclone.trans_id_tree_path('house')
         cyclone.adjust_path('house', oz, house)
         cyclone.apply()
 
@@ -1080,7 +1080,7 @@
         self.addCleanup(self.wt.unlock)
         self.assertTrue(self.wt.is_executable('file1'))
         transform, root = self.get_transform()
-        file1_id = transform.trans_id_tree_file_id('file1-id')
+        file1_id = transform.trans_id_tree_path('file1')
         transform.delete_contents(file1_id)
         transform.create_file('contents2', file1_id)
         transform.apply()
@@ -1124,7 +1124,7 @@
         transform, root = self.get_transform()
         try:
             self.assertEqual([], list(transform.iter_changes()))
-            old = transform.trans_id_tree_file_id('id-1')
+            old = transform.trans_id_tree_path('old')
             transform.unversion_file(old)
             self.assertEqual([('id-1', ('old', None), False, (True, False),
                 ('eert_toor', 'eert_toor'), ('old', 'old'), ('file', 'file'),
@@ -1162,7 +1162,7 @@
         transform, root = self.get_transform()
         try:
             old = transform.trans_id_tree_path('old')
-            subdir = transform.trans_id_tree_file_id('subdir-id')
+            subdir = transform.trans_id_tree_path('subdir')
             new = transform.trans_id_tree_path('new')
             self.assertEqual([], list(transform.iter_changes()))
 
@@ -1280,7 +1280,7 @@
         transform, root = self.get_transform()
         try:
             old = transform.trans_id_tree_path('old')
-            subdir = transform.trans_id_tree_file_id('subdir-id')
+            subdir = transform.trans_id_tree_path('subdir')
             self.assertEqual([], list(transform.iter_changes()))
             transform.delete_contents(subdir)
             transform.create_directory(subdir)
@@ -1651,7 +1651,7 @@
         self.wt.set_root_id(root_id)
         self.b = self.wt.branch
         self.tt = TreeTransform(self.wt)
-        self.root = self.tt.trans_id_tree_file_id(self.wt.get_root_id())
+        self.root = self.tt.trans_id_tree_path('')
 
 
 def conflict_text(tree, merge):
@@ -1675,7 +1675,7 @@
         with TransformPreview(tree) as tt:
             tt.unversion_file(tt.root)
             tt.version_file('new-id', tt.root)
-            foo_trans_id = tt.trans_id_tree_file_id('foo-id')
+            foo_trans_id = tt.trans_id_tree_path('foo')
             foo_tuple = ('foo', foo_trans_id)
             root_tuple = ('', tt.root)
             self.assertEqual([root_tuple, foo_tuple], tt._inventory_altered())
@@ -1687,7 +1687,7 @@
         with TransformPreview(tree) as tt:
             tt.unversion_file(tt.root)
             tt.version_file(tree.get_root_id(), tt.root)
-            foo_trans_id = tt.trans_id_tree_file_id('foo-id')
+            foo_trans_id = tt.trans_id_tree_path('foo')
             self.assertEqual([], tt._inventory_altered())
 
 
@@ -2160,7 +2160,7 @@
         self.requireFeature(HardlinkFeature)
         source = self.create_ab_tree()
         tt = TreeTransform(source)
-        trans_id = tt.trans_id_tree_file_id('file1-id')
+        trans_id = tt.trans_id_tree_path('file1')
         tt.set_executability(True, trans_id)
         tt.apply()
         self.assertTrue(source.is_executable('file1'))
@@ -2669,7 +2669,7 @@
 
     def test_resolve_create_parent_for_versioned_file(self):
         wt, tt = self.make_tt_with_versioned_dir()
-        dir_tid = tt.trans_id_tree_file_id('dir-id')
+        dir_tid = tt.trans_id_tree_path('dir')
         file_tid = tt.new_file('file', dir_tid, 'Contents', file_id='file-id')
         tt.delete_contents(dir_tid)
         tt.unversion_file(dir_tid)
@@ -2680,7 +2680,7 @@
 
     def test_non_versioned_file_create_conflict(self):
         wt, tt = self.make_tt_with_versioned_dir()
-        dir_tid = tt.trans_id_tree_file_id('dir-id')
+        dir_tid = tt.trans_id_tree_path('dir')
         tt.new_file('file', dir_tid, 'Contents')
         tt.delete_contents(dir_tid)
         tt.unversion_file(dir_tid)
@@ -2837,7 +2837,7 @@
         work_tree.add('file', 'file-id')
         preview = TransformPreview(work_tree)
         self.addCleanup(preview.finalize)
-        file_trans_id = preview.trans_id_tree_file_id('file-id')
+        file_trans_id = preview.trans_id_tree_path('file')
         preview.adjust_path('renamed', preview.root, file_trans_id)
         preview_tree = preview.get_preview_tree()
         preview_mtime = preview_tree.get_file_mtime('renamed', 'file-id')
@@ -2937,13 +2937,14 @@
         self.assertFalse(preview_tree.is_versioned('old_name/child'))
         self.assertEqual('child-id', preview_tree.path2id('new_name/child'))
 
-    def assertMatchingIterEntries(self, tt, specific_file_ids=None):
+    def assertMatchingIterEntries(self, tt, specific_files=None):
         preview_tree = tt.get_preview_tree()
         preview_result = list(preview_tree.iter_entries_by_dir(
-                              specific_file_ids))
+                              specific_files=specific_files))
         tree = tt._tree
         tt.apply()
-        actual_result = list(tree.iter_entries_by_dir(specific_file_ids))
+        actual_result = list(tree.iter_entries_by_dir(
+            specific_files=specific_files))
         self.assertEqual(actual_result, preview_result)
 
     def test_iter_entries_by_dir_new(self):
@@ -2977,13 +2978,13 @@
                        tt.trans_id_file_id('moved-id'))
         self.assertMatchingIterEntries(tt)
 
-    def test_iter_entries_by_dir_specific_file_ids(self):
+    def test_iter_entries_by_dir_specific_files(self):
         tree = self.make_branch_and_tree('tree')
         tree.set_root_id('tree-root-id')
         self.build_tree(['tree/parent/', 'tree/parent/child'])
         tree.add(['parent', 'parent/child'], ['parent-id', 'child-id'])
         tt = TreeTransform(tree)
-        self.assertMatchingIterEntries(tt, ['tree-root-id', 'child-id'])
+        self.assertMatchingIterEntries(tt, ['', 'parent/child'])
 
     def test_symlink_content_summary(self):
         self.requireFeature(SymlinkFeature)
@@ -3455,9 +3456,9 @@
 
     def test_serialize_destruction(self):
         tt = self.make_destruction_preview()
-        foo_trans_id = tt.trans_id_tree_file_id('foo-id')
+        foo_trans_id = tt.trans_id_tree_path(u'foo\u1234')
         tt.unversion_file(foo_trans_id)
-        bar_trans_id = tt.trans_id_tree_file_id('bar-id')
+        bar_trans_id = tt.trans_id_tree_path('bar')
         tt.delete_contents(bar_trans_id)
         self.assertSerializesTo(self.destruction_records(), tt)
 
@@ -3612,7 +3613,7 @@
         self.assertRaises(NotImplementedError, tt.new_orphan, 'foo', 'bar')
 
     def _set_orphan_policy(self, wt, policy):
-        wt.branch.get_config_stack().set('bzr.transform.orphan_policy',
+        wt.branch.get_config_stack().set('transform.orphan_policy',
                                                policy)
 
     def _prepare_orphan(self, wt):
@@ -3741,7 +3742,7 @@
         self.parent_tree.lock_write()
         self.addCleanup(self.parent_tree.unlock)
         self.build_tree_contents([('parent/foo', 'bar')])
-        self.parent_tree.add('foo', 'foo-id')
+        self.parent_tree.add('foo')
         self.parent_tree.commit('added foo')
         child_controldir = self.parent_tree.controldir.sprout('child')
         self.child_tree = child_controldir.open_workingtree()
@@ -3761,7 +3762,7 @@
         """If the file to be linked has modified execute bit, don't link."""
         tt = TreeTransform(self.child_tree)
         try:
-            trans_id = tt.trans_id_tree_file_id('foo-id')
+            trans_id = tt.trans_id_tree_path('foo')
             tt.set_executability(True, trans_id)
             tt.apply()
         finally:

=== modified file 'breezy/tests/test_workingtree.py'
--- breezy/tests/test_workingtree.py	2018-02-11 17:07:38 +0000
+++ breezy/tests/test_workingtree.py	2018-03-24 17:11:56 +0000
@@ -257,7 +257,8 @@
         subtree = self.make_branch_and_tree('tree/a/b')
         self.assertEqual([('tree-reference', 'b-id')],
                          [(ie.kind, ie.file_id)
-                          for path, ie in tree.iter_entries_by_dir(['b-id'])])
+                          for path, ie in tree.iter_entries_by_dir(
+                              specific_files=['a/b'])])
 
     def test_direct_subtree(self):
         tree = self.make_simple_tree()

=== modified file 'breezy/transform.py'
--- breezy/transform.py	2018-03-12 05:18:13 +0000
+++ breezy/transform.py	2018-03-24 17:11:56 +0000
@@ -93,8 +93,7 @@
 class TreeTransformBase(object):
     """The base class for TreeTransform and its kin."""
 
-    def __init__(self, tree, pb=None,
-                 case_sensitive=True):
+    def __init__(self, tree, pb=None, case_sensitive=True):
         """Constructor.
 
         :param tree: The tree that will be transformed, but not necessarily
@@ -135,7 +134,7 @@
         # The trans_id that will be used as the tree root
         root_id = tree.get_root_id()
         if root_id is not None:
-            self._new_root = self.trans_id_tree_file_id(root_id)
+            self._new_root = self.trans_id_tree_path('')
         else:
             self._new_root = None
         # Indicator of whether the transform has been applied
@@ -219,7 +218,7 @@
         # the physical root needs a new transaction id
         self._tree_path_ids.pop("")
         self._tree_id_paths.pop(old_root)
-        self._new_root = self.trans_id_tree_file_id(self._tree.get_root_id())
+        self._new_root = self.trans_id_tree_path('')
         if parent == old_root:
             parent = self._new_root
         self.adjust_path(name, parent, old_root)
@@ -288,17 +287,6 @@
         del self._new_parent[old_new_root]
         del self._new_name[old_new_root]
 
-    def trans_id_tree_file_id(self, inventory_id):
-        """Determine the transaction id of a working tree file.
-
-        This reflects only files that already exist, not ones that will be
-        added by transactions.
-        """
-        if inventory_id is None:
-            raise ValueError('None is not a valid file id')
-        path = self._tree.id2path(inventory_id)
-        return self.trans_id_tree_path(path)
-
     def trans_id_file_id(self, file_id):
         """Determine or set the transaction id associated with a file ID.
         A new id is only created for file_ids that were never present.  If
@@ -311,8 +299,8 @@
             return self._r_new_id[file_id]
         else:
             try:
-                next(self._tree.iter_entries_by_dir([file_id]))
-            except StopIteration:
+                path = self._tree.id2path(file_id)
+            except errors.NoSuchId:
                 if file_id in self._non_present_ids:
                     return self._non_present_ids[file_id]
                 else:
@@ -320,7 +308,7 @@
                     self._non_present_ids[file_id] = trans_id
                     return trans_id
             else:
-                return self.trans_id_tree_file_id(file_id)
+                return self.trans_id_tree_path(path)
 
     def trans_id_tree_path(self, path):
         """Determine (and maybe set) the transaction ID for a tree path."""
@@ -457,12 +445,14 @@
         else:
             return self.tree_kind(trans_id)
 
+    def tree_path(self, trans_id):
+        """Determine the tree path associated with the trans_id."""
+        return self._tree_id_paths.get(trans_id)
+
     def tree_file_id(self, trans_id):
         """Determine the file id associated with the trans_id in the tree"""
-        try:
-            path = self._tree_id_paths[trans_id]
-        except KeyError:
-            # the file is a new, unversioned file, or invalid trans_id
+        path = self.tree_path(trans_id)
+        if path is None:
             return None
         # the file is old; the old id is still valid