Merge lp:~jelmer/brz/misc into lp:brz

[Jelmer Vernooij]

Various smaller fixes:

 * Expect foreign branch nicks to be text_type; this is consistent with the test for regular branches
 * Use skipTest rather than skip
 * Avoid specifying revision_id in two more tests

[Martin Packman (gz)]

Should have prerequ branch lp:~jelmer/brz/swap-arguments marked.

The new revisions all look good to me.

review: Approve

=== modified file 'Makefile'
--- Makefile	2017-10-26 11:10:38 +0000
+++ Makefile	2017-11-19 19:02:26 +0000
@@ -50,7 +50,7 @@
 	# Generate a stream for PQM to watch.
 	-$(RM) -f selftest.log
 	echo `date` ": selftest starts" 1>&2
-	BRZ_PLUGIN_PATH=$(BRZ_PLUGIN_PATH) $(PYTHON3) -Werror -Wignore::ImportWarning -O \
+	BRZ_PLUGIN_PATH=$(BRZ_PLUGIN_PATH) $(PYTHON3) -Wignore::ImportWarning -O \
 	  ./brz selftest -Oselftest.timeout=120 --load-list=python3.passing \
 	  --subunit2 $(tests) | tee selftest.log | subunit-2to1
 	echo `date` ": selftest ends" 1>&2

=== modified file 'breezy/annotate.py'
--- breezy/annotate.py	2017-11-12 13:53:51 +0000
+++ breezy/annotate.py	2017-11-19 19:02:26 +0000
@@ -53,19 +53,20 @@
     )
 
 
-def annotate_file_tree(tree, file_id, to_file, verbose=False, full=False,
-    show_ids=False, branch=None):
+def annotate_file_tree(tree, path, to_file, verbose=False, full=False,
+    show_ids=False, branch=None, file_id=None):
     """Annotate file_id in a tree.
 
     The tree should already be read_locked() when annotate_file_tree is called.
 
     :param tree: The tree to look for revision numbers and history from.
-    :param file_id: The file_id to annotate.
+    :param path: The path to annotate
     :param to_file: The file to output the annotation to.
     :param verbose: Show all details rather than truncating to ensure
         reasonable text width.
     :param full: XXXX Not sure what this does.
     :param show_ids: Show revision ids in the annotation output.
+    :param file_id: The file_id to annotate (must match file path)
     :param branch: Branch to use for revision revno lookups
     """
     if branch is None:
@@ -74,7 +75,7 @@
         to_file = sys.stdout
 
     # Handle the show_ids case
-    annotations = list(tree.annotate_iter(file_id))
+    annotations = list(tree.annotate_iter(path, file_id))
     if show_ids:
         return _show_id_annotations(annotations, to_file, full)
 

=== modified file 'breezy/branch.py'
--- breezy/branch.py	2017-11-12 13:53:51 +0000
+++ breezy/branch.py	2017-11-19 19:02:26 +0000
@@ -1421,7 +1421,7 @@
             for path, file_id in basis_tree.iter_references():
                 reference_parent = self.reference_parent(file_id, path)
                 reference_parent.create_checkout(tree.abspath(path),
-                    basis_tree.get_reference_revision(file_id, path),
+                    basis_tree.get_reference_revision(path, file_id),
                     lightweight)
         return tree
 

=== modified file 'breezy/branchbuilder.py'
--- breezy/branchbuilder.py	2017-11-16 00:39:04 +0000
+++ breezy/branchbuilder.py	2017-11-19 19:02:26 +0000
@@ -280,10 +280,12 @@
         for from_relpath, to_relpath in pending.to_rename:
             tree.rename_one(from_relpath, to_relpath)
         if pending.to_unversion_ids:
-            tree.unversion(pending.to_unversion_ids)
+            tree.unversion([tree.id2path(fid) for fid in pending.to_unversion_ids])
         tree.add(pending.to_add_files, pending.to_add_file_ids, pending.to_add_kinds)
         for file_id, content in viewitems(pending.new_contents):
-            tree.put_file_bytes_non_atomic(file_id, content)
+            tree.put_file_bytes_non_atomic(
+                    tree.id2path(file_id), content,
+                    file_id=file_id)
 
     def get_branch(self):
         """Return the branch created by the builder."""

=== modified file 'breezy/builtins.py'
--- breezy/builtins.py	2017-11-12 13:53:51 +0000
+++ breezy/builtins.py	2017-11-19 19:02:26 +0000
@@ -1050,10 +1050,11 @@
                 into_existing = False
             else:
                 # 'fix' the case of a potential 'from'
-                from_id = tree.path2id(
-                            tree.get_canonical_inventory_path(rel_names[0]))
+                from_path = tree.get_canonical_inventory_path(rel_names[0])
+                from_id = tree.path2id(from_path)
                 if (not osutils.lexists(names_list[0]) and
-                    from_id and tree.stored_kind(from_id) == "directory"):
+                    from_id and
+                    tree.stored_kind(from_path, from_id) == "directory"):
                     into_existing = False
         # move/rename
         if into_existing:
@@ -3404,9 +3405,9 @@
             from .filter_tree import ContentFilterTree
             filter_tree = ContentFilterTree(rev_tree,
                 rev_tree._content_filter_stack)
-            content = filter_tree.get_file_text(actual_file_id)
+            content = filter_tree.get_file_text(relpath, actual_file_id)
         else:
-            content = rev_tree.get_file_text(actual_file_id)
+            content = rev_tree.get_file_text(relpath, actual_file_id)
         self.cleanup_now()
         self.outf.write(content)
 
@@ -4697,7 +4698,7 @@
                 if file_id is None:
                     raise errors.NotVersionedError(filename)
                 interesting_ids.add(file_id)
-                if tree.kind(file_id) != "directory":
+                if tree.kind(filename, file_id) != "directory":
                     continue
 
                 # FIXME: Support nested trees
@@ -5190,11 +5191,11 @@
         if wt is not None and revision is None:
             # If there is a tree and we're not annotating historical
             # versions, annotate the working tree's content.
-            annotate_file_tree(wt, file_id, self.outf, long, all,
-                show_ids=show_ids)
+            annotate_file_tree(wt, relpath, self.outf, long, all,
+                show_ids=show_ids, file_id=file_id)
         else:
-            annotate_file_tree(tree, file_id, self.outf, long, all,
-                show_ids=show_ids, branch=branch)
+            annotate_file_tree(tree, relpath, self.outf, long, all,
+                show_ids=show_ids, branch=branch, file_id=file_id)
 
 
 class cmd_re_sign(Command):

=== modified file 'breezy/bundle/bundle_data.py'
--- breezy/bundle/bundle_data.py	2017-11-12 13:53:51 +0000
+++ breezy/bundle/bundle_data.py	2017-11-19 19:02:26 +0000
@@ -476,7 +476,7 @@
         self._renamed_r = {} # new_path => old_path
         self._new_id = {} # new_path => new_id
         self._new_id_r = {} # new_id => new_path
-        self._kinds = {} # new_id => kind
+        self._kinds = {} # new_path => kind
         self._last_changed = {} # new_id => revision_id
         self._executable = {} # new_id => executable value
         self.patches = {}
@@ -502,7 +502,7 @@
         """Files that don't exist in base need a new id."""
         self._new_id[new_path] = new_id
         self._new_id_r[new_id] = new_path
-        self._kinds[new_id] = kind
+        self._kinds[new_path] = kind
 
     def note_last_changed(self, file_id, revision_id):
         if (file_id in self._last_changed
@@ -618,7 +618,7 @@
         new_path = self.id2path(file_id)
         return self.base_tree.path2id(new_path)
 
-    def get_file(self, file_id):
+    def get_file(self, path, file_id=None):
         """Return a file-like object containing the new contents of the
         file given by file_id.
 
@@ -626,16 +626,19 @@
                 in the text-store, so that the file contents would
                 then be cached.
         """
+        if file_id is None:
+            file_id = self.path2id(path)
         base_id = self.old_contents_id(file_id)
         if (base_id is not None and
             base_id != self.base_tree.get_root_id()):
-            patch_original = self.base_tree.get_file(base_id)
+            patch_original = self.base_tree.get_file(
+                    self.base_tree.id2path(base_id), base_id)
         else:
             patch_original = None
-        file_patch = self.patches.get(self.id2path(file_id))
+        file_patch = self.patches.get(path)
         if file_patch is None:
             if (patch_original is None and
-                self.kind(file_id) == 'directory'):
+                self.kind(path, file_id) == 'directory'):
                 return BytesIO()
             if patch_original is None:
                 raise AssertionError("None: %s" % file_id)
@@ -646,54 +649,50 @@
                 'Malformed patch for %s, %r' % (file_id, file_patch))
         return patched_file(file_patch, patch_original)
 
-    def get_symlink_target(self, file_id, path=None):
-        if path is None:
-            path = self.id2path(file_id)
+    def get_symlink_target(self, path, file_id=None):
         try:
             return self._targets[path]
         except KeyError:
-            return self.base_tree.get_symlink_target(file_id)
-
-    def kind(self, file_id):
-        if file_id in self._kinds:
-            return self._kinds[file_id]
-        return self.base_tree.kind(file_id)
-
-    def get_file_revision(self, file_id):
-        path = self.id2path(file_id)
+            return self.base_tree.get_symlink_target(path, file_id)
+
+    def kind(self, path, file_id=None):
+        try:
+            return self._kinds[path]
+        except KeyError:
+            return self.base_tree.kind(path, file_id)
+
+    def get_file_revision(self, path, file_id=None):
         if path in self._last_changed:
             return self._last_changed[path]
         else:
-            return self.base_tree.get_file_revision(file_id)
+            return self.base_tree.get_file_revision(path, file_id)
 
-    def is_executable(self, file_id):
-        path = self.id2path(file_id)
+    def is_executable(self, path, file_id=None):
         if path in self._executable:
             return self._executable[path]
         else:
-            return self.base_tree.is_executable(file_id)
+            return self.base_tree.is_executable(path, file_id)
 
-    def get_last_changed(self, file_id):
-        path = self.id2path(file_id)
+    def get_last_changed(self, path, file_id=None):
         if path in self._last_changed:
             return self._last_changed[path]
-        return self.base_tree.get_file_revision(file_id)
+        return self.base_tree.get_file_revision(path, file_id)
 
-    def get_size_and_sha1(self, file_id):
+    def get_size_and_sha1(self, new_path, file_id=None):
         """Return the size and sha1 hash of the given file id.
         If the file was not locally modified, this is extracted
         from the base_tree. Rather than re-reading the file.
         """
-        new_path = self.id2path(file_id)
         if new_path is None:
             return None, None
         if new_path not in self.patches:
             # If the entry does not have a patch, then the
             # contents must be the same as in the base_tree
-            text_size = self.base_tree.get_file_size(file_id)
-            text_sha1 = self.base_tree.get_file_sha1(file_id)
+            base_path = self.base_tree.id2path(file_id)
+            text_size = self.base_tree.get_file_size(base_path, file_id)
+            text_sha1 = self.base_tree.get_file_sha1(base_path, file_id)
             return text_size, text_sha1
-        fileobj = self.get_file(file_id)
+        fileobj = self.get_file(new_path, file_id)
         content = fileobj.read()
         return len(content), sha_string(content)
 
@@ -705,32 +704,30 @@
         from os.path import dirname, basename
         inv = Inventory(None, self.revision_id)
 
-        def add_entry(file_id):
-            path = self.id2path(file_id)
-            if path is None:
-                return
+        def add_entry(path, file_id):
             if path == '':
                 parent_id = None
             else:
                 parent_path = dirname(path)
                 parent_id = self.path2id(parent_path)
 
-            kind = self.kind(file_id)
-            revision_id = self.get_last_changed(file_id)
+            kind = self.kind(path, file_id)
+            revision_id = self.get_last_changed(path, file_id)
 
             name = basename(path)
             if kind == 'directory':
                 ie = InventoryDirectory(file_id, name, parent_id)
             elif kind == 'file':
                 ie = InventoryFile(file_id, name, parent_id)
-                ie.executable = self.is_executable(file_id)
+                ie.executable = self.is_executable(path, file_id)
             elif kind == 'symlink':
                 ie = InventoryLink(file_id, name, parent_id)
-                ie.symlink_target = self.get_symlink_target(file_id, path)
+                ie.symlink_target = self.get_symlink_target(path, file_id)
             ie.revision = revision_id
 
             if kind == 'file':
-                ie.text_size, ie.text_sha1 = self.get_size_and_sha1(file_id)
+                ie.text_size, ie.text_sha1 = self.get_size_and_sha1(
+                        path, file_id)
                 if ie.text_size is None:
                     raise BzrError(
                         'Got a text_size of None for file_id %r' % file_id)
@@ -738,7 +735,7 @@
 
         sorted_entries = self.sorted_path_id()
         for path, file_id in sorted_entries:
-            add_entry(file_id)
+            add_entry(path, file_id)
 
         return inv
 

=== modified file 'breezy/bundle/serializer/v08.py'
--- breezy/bundle/serializer/v08.py	2017-08-26 13:58:53 +0000
+++ breezy/bundle/serializer/v08.py	2017-11-19 19:02:26 +0000
@@ -257,9 +257,9 @@
         new_label = ''
 
         def do_diff(file_id, old_path, new_path, action, force_binary):
-            def tree_lines(tree, require_text=False):
+            def tree_lines(tree, path, require_text=False):
                 if tree.has_id(file_id):
-                    tree_file = tree.get_file(file_id)
+                    tree_file = tree.get_file(path, file_id)
                     if require_text is True:
                         tree_file = text_file(tree_file)
                     return tree_file.readlines()
@@ -269,14 +269,14 @@
             try:
                 if force_binary:
                     raise errors.BinaryFile()
-                old_lines = tree_lines(old_tree, require_text=True)
-                new_lines = tree_lines(new_tree, require_text=True)
+                old_lines = tree_lines(old_tree, old_path, require_text=True)
+                new_lines = tree_lines(new_tree, new_path, require_text=True)
                 action.write(self.to_file)
                 internal_diff(old_path, old_lines, new_path, new_lines,
                               self.to_file)
             except errors.BinaryFile:
-                old_lines = tree_lines(old_tree, require_text=False)
-                new_lines = tree_lines(new_tree, require_text=False)
+                old_lines = tree_lines(old_tree, old_path, require_text=False)
+                new_lines = tree_lines(new_tree, new_path, require_text=False)
                 action.add_property('encoding', 'base64')
                 action.write(self.to_file)
                 binary_diff(old_path, old_lines, new_path, new_lines,
@@ -304,7 +304,7 @@
         for path, file_id, kind in delta.added:
             action = Action('added', [kind, path], [('file-id', file_id)])
             meta_modified = (kind=='file' and
-                             new_tree.is_executable(file_id))
+                             new_tree.is_executable(path, file_id))
             finish_action(action, file_id, kind, meta_modified, True,
                           DEVNULL, path)
 
@@ -321,13 +321,13 @@
                           path, path)
 
         for path, file_id, kind in delta.unchanged:
-            new_rev = new_tree.get_file_revision(file_id)
+            new_rev = new_tree.get_file_revision(path, file_id)
             if new_rev is None:
                 continue
-            old_rev = old_tree.get_file_revision(file_id)
+            old_rev = old_tree.get_file_revision(path, file_id)
             if new_rev != old_rev:
-                action = Action('modified', [new_tree.kind(file_id),
-                                             new_tree.id2path(file_id)])
+                action = Action('modified', [new_tree.kind(path, file_id),
+                                             path])
                 action.add_utf8_property('last-changed', new_rev)
                 action.write(self.to_file)
 

=== modified file 'breezy/bzr/bzrdir.py'
--- breezy/bzr/bzrdir.py	2017-08-05 01:03:53 +0000
+++ breezy/bzr/bzrdir.py	2017-11-19 19:02:26 +0000
@@ -477,7 +477,7 @@
                 target = urlutils.join(url, urlutils.escape(path))
                 sublocation = source_branch.reference_parent(file_id, path)
                 sublocation.controldir.sprout(target,
-                    basis.get_reference_revision(file_id, path),
+                    basis.get_reference_revision(path, file_id),
                     force_new_repo=force_new_repo, recurse=recurse,
                     stacked=stacked)
         return result

=== modified file 'breezy/bzr/inventory.py'
--- breezy/bzr/inventory.py	2017-11-12 18:17:03 +0000
+++ breezy/bzr/inventory.py	2017-11-19 19:02:26 +0000
@@ -462,15 +462,22 @@
         from_file_id = self.file_id
         if to_entry:
             to_file_id = to_entry.file_id
+            to_path = to_tree.id2path(to_file_id)
         else:
             to_file_id = None
+            to_path = None
+        if from_file_id is not None:
+            from_path = tree.id2path(from_file_id)
+        else:
+            from_path = None
         if reverse:
             to_file_id, from_file_id = from_file_id, to_file_id
             tree, to_tree = to_tree, tree
             from_label, to_label = to_label, from_label
         differ = DiffText(tree, to_tree, output_to, 'utf-8', '', '',
                           text_diff)
-        return differ.diff_text(from_file_id, to_file_id, from_label, to_label)
+        return differ.diff_text(from_path, to_path, from_label, to_label,
+                                from_file_id, to_file_id)
 
     def has_text(self):
         """See InventoryEntry.has_text."""
@@ -482,10 +489,10 @@
 
     def _read_tree_state(self, path, work_tree):
         """See InventoryEntry._read_tree_state."""
-        self.text_sha1 = work_tree.get_file_sha1(self.file_id, path=path)
+        self.text_sha1 = work_tree.get_file_sha1(path, self.file_id)
         # FIXME: 20050930 probe for the text size when getting sha1
         # in _read_tree_state
-        self.executable = work_tree.is_executable(self.file_id, path=path)
+        self.executable = work_tree.is_executable(path, self.file_id)
 
     def __repr__(self):
         return ("%s(%r, %r, parent_id=%r, sha1=%r, len=%s, revision=%s)"
@@ -576,7 +583,8 @@
 
     def _read_tree_state(self, path, work_tree):
         """See InventoryEntry._read_tree_state."""
-        self.symlink_target = work_tree.get_symlink_target(self.file_id)
+        self.symlink_target = work_tree.get_symlink_target(
+                work_tree.id2path(self.file_id), self.file_id)
 
     def _forget_tree_state(self):
         self.symlink_target = None
@@ -609,7 +617,7 @@
         """Populate fields in the inventory entry from the given tree.
         """
         self.reference_revision = work_tree.get_reference_revision(
-            self.file_id, path)
+            path, self.file_id)
 
     def _forget_tree_state(self):
         self.reference_revision = None
@@ -745,8 +753,13 @@
             if (not yield_parents and specific_file_ids is not None and
                 len(specific_file_ids) == 1):
                 file_id = list(specific_file_ids)[0]
-                if self.has_id(file_id):
-                    yield self.id2path(file_id), self[file_id]
+                if file_id is not None:
+                    try:
+                        path = self.id2path(file_id)
+                    except errors.NoSuchId:
+                        pass
+                    else:
+                        yield path, self[file_id]
                 return
             from_dir = self.root
             if (specific_file_ids is None or yield_parents or

=== modified file 'breezy/bzr/inventorytree.py'
--- breezy/bzr/inventorytree.py	2017-11-12 13:53:51 +0000
+++ breezy/bzr/inventorytree.py	2017-11-19 19:02:26 +0000
@@ -170,14 +170,20 @@
         with self.lock_read():
             return self._path2inv_file_id(path)[1]
 
-    def _path2inv_file_id(self, path):
+    def _path2inv_file_id(self, path, file_id=None):
         """Lookup a inventory and inventory file id by path.
 
         :param path: Path to look up
+        :param file_id: Optional file_id matching path, if known.
         :return: tuple with inventory and inventory file id
         """
-        # FIXME: Support nested trees
-        return self.root_inventory, self.root_inventory.path2id(path)
+        if file_id is not None:
+            inv, inv_file_id = self._unpack_file_id(file_id)
+        else:
+            # FIXME: Support nested trees
+            inv = self.root_inventory
+            inv_file_id = self.root_inventory.path2id(path)
+        return inv, inv_file_id
 
     def id2path(self, file_id):
         """Return the path for a file id.
@@ -606,33 +612,36 @@
         RevisionTree.__init__(self, repository, revision_id)
         self._inventory = inv
 
-    def get_file_mtime(self, file_id, path=None):
-        inv, inv_file_id = self._unpack_file_id(file_id)
-        ie = inv[inv_file_id]
+    def get_file_mtime(self, path, file_id=None):
+        inv, inv_file_id = self._path2inv_file_id(path, file_id)
+        try:
+            ie = inv[inv_file_id]
+        except errors.NoSuchId:
+            raise errors.NoSuchFile(path)
         try:
             revision = self._repository.get_revision(ie.revision)
         except errors.NoSuchRevision:
             raise FileTimestampUnavailable(self.id2path(file_id))
         return revision.timestamp
 
-    def get_file_size(self, file_id):
-        inv, inv_file_id = self._unpack_file_id(file_id)
+    def get_file_size(self, path, file_id=None):
+        inv, inv_file_id = self._path2inv_file_id(path, file_id)
         return inv[inv_file_id].text_size
 
-    def get_file_sha1(self, file_id, path=None, stat_value=None):
-        inv, inv_file_id = self._unpack_file_id(file_id)
+    def get_file_sha1(self, path, file_id=None, stat_value=None):
+        inv, inv_file_id = self._path2inv_file_id(path, file_id)
         ie = inv[inv_file_id]
         if ie.kind == "file":
             return ie.text_sha1
         return None
 
-    def get_file_revision(self, file_id, path=None):
-        inv, inv_file_id = self._unpack_file_id(file_id)
+    def get_file_revision(self, path, file_id=None):
+        inv, inv_file_id = self._path2inv_file_id(path, file_id)
         ie = inv[inv_file_id]
         return ie.revision
 
-    def is_executable(self, file_id, path=None):
-        inv, inv_file_id = self._unpack_file_id(file_id)
+    def is_executable(self, path, file_id=None):
+        inv, inv_file_id = self._path2inv_file_id(path, file_id)
         ie = inv[inv_file_id]
         if ie.kind != "file":
             return False
@@ -658,22 +667,22 @@
         for path, entry in entries:
             yield path, 'V', entry.kind, entry.file_id, entry
 
-    def get_symlink_target(self, file_id, path=None):
-        inv, inv_file_id = self._unpack_file_id(file_id)
+    def get_symlink_target(self, path, file_id=None):
+        inv, inv_file_id = self._path2inv_file_id(path, file_id)
         ie = inv[inv_file_id]
         # Inventories store symlink targets in unicode
         return ie.symlink_target
 
-    def get_reference_revision(self, file_id, path=None):
-        inv, inv_file_id = self._unpack_file_id(file_id)
+    def get_reference_revision(self, path, file_id=None):
+        inv, inv_file_id = self._path2inv_file_id(path, file_id)
         return inv[inv_file_id].reference_revision
 
     def get_root_id(self):
         if self.root_inventory.root:
             return self.root_inventory.root.file_id
 
-    def kind(self, file_id):
-        inv, inv_file_id = self._unpack_file_id(file_id)
+    def kind(self, path, file_id=None):
+        inv, inv_file_id = self._path2inv_file_id(path, file_id)
         return inv[inv_file_id].kind
 
     def path_content_summary(self, path):
@@ -730,7 +739,7 @@
         """See Tree.iter_files_bytes.
 
         This version is implemented on top of Repository.iter_files_bytes"""
-        repo_desired_files = [(f, self.get_file_revision(f), i)
+        repo_desired_files = [(f, self.get_file_revision(self.id2path(f), f), i)
                               for f, i in desired_files]
         try:
             for result in self._repository.iter_files_bytes(repo_desired_files):
@@ -738,10 +747,12 @@
         except errors.RevisionNotPresent as e:
             raise errors.NoSuchFile(e.file_id)
 
-    def annotate_iter(self, file_id,
+    def annotate_iter(self, path, file_id=None,
                       default_revision=revision.CURRENT_REVISION):
         """See Tree.annotate_iter"""
-        text_key = (file_id, self.get_file_revision(file_id))
+        if file_id is None:
+            file_id = self.path2id(path)
+        text_key = (file_id, self.get_file_revision(path, file_id))
         annotator = self._repository.texts.get_annotator()
         annotations = annotator.annotate_flat(text_key)
         return [(key[-1], line) for key, line in annotations]

=== modified file 'breezy/bzr/vf_repository.py'
--- breezy/bzr/vf_repository.py	2017-11-14 01:20:51 +0000
+++ breezy/bzr/vf_repository.py	2017-11-19 19:02:26 +0000
@@ -484,7 +484,7 @@
                             nostore_sha = parent_entry.text_sha1
                     else:
                         nostore_sha = None
-                    file_obj, stat_value = tree.get_file_with_stat(file_id, change[1][1])
+                    file_obj, stat_value = tree.get_file_with_stat(change[1][1], file_id)
                     try:
                         text = file_obj.read()
                     finally:
@@ -501,7 +501,7 @@
                         entry.text_sha1 = parent_entry.text_sha1
                 elif kind == 'symlink':
                     # Wants a path hint?
-                    entry.symlink_target = tree.get_symlink_target(file_id)
+                    entry.symlink_target = tree.get_symlink_target(change[1][1], file_id)
                     if (carry_over_possible and
                         parent_entry.symlink_target == entry.symlink_target):
                         carried_over = True
@@ -523,7 +523,7 @@
                         # references.
                         raise errors.UnsupportedOperation(tree.add_reference,
                             self.repository)
-                    reference_revision = tree.get_reference_revision(change[0])
+                    reference_revision = tree.get_reference_revision(change[1][1], change[0])
                     entry.reference_revision = reference_revision
                     if (carry_over_possible and
                         parent_entry.reference_revision == reference_revision):
@@ -2878,11 +2878,13 @@
         for revision, tree in viewitems(parent_trees):
             if not tree.has_id(ie.file_id):
                 continue
-            parent_id = tree.get_file_revision(ie.file_id)
+            path = tree.id2path(ie.file_id)
+            parent_id = tree.get_file_revision(path, ie.file_id)
             if parent_id in text_parents:
                 continue
             text_parents.append((ie.file_id, parent_id))
-        lines = revision_tree.get_file(ie.file_id).readlines()
+        revision_tree_path = revision_tree.id2path(ie.file_id)
+        lines = revision_tree.get_file(revision_tree_path, ie.file_id).readlines()
         repository.texts.add_lines(text_key, text_parents, lines)
     try:
         # install the inventory

=== modified file 'breezy/bzr/workingtree.py'
--- breezy/bzr/workingtree.py	2017-11-12 13:53:51 +0000
+++ breezy/bzr/workingtree.py	2017-11-19 19:02:26 +0000
@@ -427,7 +427,7 @@
                         else:
                             new_status = '?'
                         # XXX: Really should be a more abstract reporter interface
-                        kind_ch = osutils.kind_marker(self.kind(fid))
+                        kind_ch = osutils.kind_marker(self.kind(f, fid))
                         to_file.write(new_status + '       ' + f + kind_ch + '\n')
                     # Unversion file
                     inv_delta.append((f, None, fid, None))
@@ -565,7 +565,7 @@
         ignore_globs.update(ignores.get_runtime_ignores())
         ignore_globs.update(ignores.get_user_ignores())
         if self.has_filename(breezy.IGNORE_FILENAME):
-            f = self.get_file_byname(breezy.IGNORE_FILENAME)
+            f = self.get_file(breezy.IGNORE_FILENAME)
             try:
                 ignore_globs.update(ignores.parse_ignore_file(f))
             finally:
@@ -724,15 +724,13 @@
             mode=self.controldir._get_file_mode())
         self._inventory_is_modified = False
 
-    def get_file_mtime(self, file_id, path=None):
+    def get_file_mtime(self, path, file_id=None):
         """See Tree.get_file_mtime."""
-        if not path:
-            path = self.id2path(file_id)
         try:
             return os.lstat(self.abspath(path)).st_mtime
         except OSError as e:
             if e.errno == errno.ENOENT:
-                raise FileTimestampUnavailable(path)
+                raise errors.NoSuchFile(path)
             raise
 
     def _is_executable_from_path_and_stat_from_basis(self, path, stat_result):
@@ -747,13 +745,11 @@
         mode = stat_result.st_mode
         return bool(stat.S_ISREG(mode) and stat.S_IEXEC & mode)
 
-    def is_executable(self, file_id, path=None):
+    def is_executable(self, path, file_id=None):
         if not self._supports_executable():
-            inv, inv_file_id = self._unpack_file_id(file_id)
+            inv, inv_file_id = self._path2inv_file_id(path, file_id)
             return inv[inv_file_id].executable
         else:
-            if not path:
-                path = self.id2path(file_id)
             mode = os.lstat(self.abspath(path)).st_mode
             return bool(stat.S_ISREG(mode) and stat.S_IEXEC & mode)
 
@@ -799,7 +795,7 @@
         # raise if there was no inventory, or if we read the wrong inventory.
         raise errors.NoSuchRevisionInTree(self, revision_id)
 
-    def annotate_iter(self, file_id,
+    def annotate_iter(self, path, file_id=None,
                       default_revision=_mod_revision.CURRENT_REVISION):
         """See Tree.annotate_iter
 
@@ -811,15 +807,19 @@
         attribution will be correct).
         """
         with self.lock_read():
+            if file_id is None:
+                file_id = self.path2id(path)
             maybe_file_parent_keys = []
             for parent_id in self.get_parent_ids():
                 try:
                     parent_tree = self.revision_tree(parent_id)
                 except errors.NoSuchRevisionInTree:
-                    parent_tree = self.branch.repository.revision_tree(parent_id)
+                    parent_tree = self.branch.repository.revision_tree(
+                            parent_id)
                 with parent_tree.lock_read():
+
                     try:
-                        kind = parent_tree.kind(file_id)
+                        kind = parent_tree.kind(path, file_id)
                     except errors.NoSuchId:
                         continue
                     if kind != 'file':
@@ -827,8 +827,10 @@
                         # directories have a "text" which is the empty text, and we
                         # know that won't mess up annotations. But it seems cleaner
                         continue
+                    parent_path = parent_tree.id2path(file_id)
                     parent_text_key = (
-                        file_id, parent_tree.get_file_revision(file_id))
+                        file_id,
+                        parent_tree.get_file_revision(parent_path, file_id))
                     if parent_text_key not in maybe_file_parent_keys:
                         maybe_file_parent_keys.append(parent_text_key)
             graph = _mod_graph.Graph(self.branch.repository.texts)
@@ -840,7 +842,7 @@
 
             # Now we have the parents of this content
             annotator = self.branch.repository.texts.get_annotator()
-            text = self.get_file_text(file_id)
+            text = self.get_file_text(path, file_id)
             this_key =(file_id, default_revision)
             annotator.add_special_text(this_key, file_parent_keys, text)
             annotations = [(key[-1], line)
@@ -889,7 +891,8 @@
                     if not self.has_id(file_id):
                         continue
                     text_hash = s.get("hash")
-                    if text_hash == self.get_file_sha1(file_id):
+                    path = self.id2path(file_id)
+                    if text_hash == self.get_file_sha1(path, file_id):
                         merge_hashes[file_id] = text_hash
                 return merge_hashes
             finally:
@@ -1413,19 +1416,28 @@
             inv.remove_recursive_id(to_id)
         inv.rename(entry.from_id, entry.to_parent_id, entry.to_tail)
 
-    def unversion(self, file_ids):
-        """Remove the file ids in file_ids from the current versioned set.
+    def unversion(self, paths, file_ids=None):
+        """Remove the paths in paths from the current versioned set.
 
-        When a file_id is unversioned, all of its children are automatically
+        When a path is unversioned, all of its children are automatically
         unversioned.
 
-        :param file_ids: The file ids to stop versioning.
+        :param paths: The paths to stop versioning.
+        :param file_ids: Optional file_ids for the paths
         :raises: NoSuchId if any fileid is not currently versioned.
         """
         with self.lock_tree_write():
-            for file_id in file_ids:
-                if not self._inventory.has_id(file_id):
-                    raise errors.NoSuchId(self, file_id)
+            if file_ids is not None:
+                for file_id in file_ids:
+                    if not self._inventory.has_id(file_id):
+                        raise errors.NoSuchId(self, file_id)
+            else:
+                file_ids = set()
+                for path in paths:
+                    file_id = self._inventory.path2id(path)
+                    if file_id is None:
+                        raise errors.NoSuchFile(self, 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)
@@ -1440,9 +1452,9 @@
                 # - RBC 20060907
                 self._write_inventory(self._inventory)
 
-    def stored_kind(self, file_id):
+    def stored_kind(self, path, file_id=None):
         """See Tree.stored_kind"""
-        inv, inv_file_id = self._unpack_file_id(file_id)
+        inv, inv_file_id = self._path2inv_file_id(path, file_id)
         return inv[inv_file_id].kind
 
     def extras(self):

=== modified file 'breezy/bzr/workingtree_3.py'
--- breezy/bzr/workingtree_3.py	2017-08-29 13:25:07 +0000
+++ breezy/bzr/workingtree_3.py	2017-11-19 19:02:26 +0000
@@ -82,10 +82,11 @@
                 trace.mutter('Could not write hashcache for %s\nError: %s',
                               self._hashcache.cache_file_name(), e)
 
-    def get_file_sha1(self, file_id, path=None, stat_value=None):
+    def get_file_sha1(self, path, file_id=None, stat_value=None):
         with self.lock_read():
-            if not path:
-                path = self._inventory.id2path(file_id)
+            # To make sure NoSuchFile gets raised..
+            if self.path2id(path) is None:
+                raise errors.NoSuchFile(path)
             return self._hashcache.get_sha1(path, stat_value)
 
 

=== modified file 'breezy/bzr/workingtree_4.py'
--- breezy/bzr/workingtree_4.py	2017-11-12 13:53:51 +0000
+++ breezy/bzr/workingtree_4.py	2017-11-19 19:02:26 +0000
@@ -303,7 +303,7 @@
         with self.lock_tree_write():
             for pos, f in enumerate(files):
                 if kinds[pos] is None:
-                    kinds[pos] = self._kind(f)
+                    kinds[pos] = self.kind(f)
 
     def _generate_inventory(self):
         """Create and set self.inventory from the dirstate object.
@@ -393,11 +393,11 @@
             path = path.encode('utf8')
         return state._get_entry(0, fileid_utf8=file_id, path_utf8=path)
 
-    def get_file_sha1(self, file_id, path=None, stat_value=None):
+    def get_file_sha1(self, path, file_id=None, stat_value=None):
         # check file id is valid unconditionally.
         entry = self._get_entry(file_id=file_id, path=path)
         if entry[0] is None:
-            raise errors.NoSuchId(self, file_id)
+            raise errors.NoSuchFile(self, path)
         if path is None:
             path = pathjoin(entry[0][0], entry[0][1]).decode('utf8')
 
@@ -415,7 +415,7 @@
             stat_value=stat_value)
         if entry[1][0][0] == b'f':
             if link_or_sha1 is None:
-                file_obj, statvalue = self.get_file_with_stat(file_id, path)
+                file_obj, statvalue = self.get_file_with_stat(path, file_id)
                 try:
                     sha1 = osutils.sha_file(file_obj)
                 finally:
@@ -448,14 +448,11 @@
         with self.lock_read():
             return self.current_dirstate().get_parent_ids()
 
-    def get_reference_revision(self, file_id, path=None):
+    def get_reference_revision(self, path, file_id=None):
         # referenced tree's revision is whatever's currently there
-        return self.get_nested_tree(file_id, path).last_revision()
+        return self.get_nested_tree(path, file_id).last_revision()
 
-    def get_nested_tree(self, file_id, path=None):
-        if path is None:
-            path = self.id2path(file_id)
-        # else: check file_id is at path?
+    def get_nested_tree(self, path, file_id=None):
         return WorkingTree.open(self.abspath(path))
 
     def get_root_id(self):
@@ -492,7 +489,7 @@
             return False # Missing entries are not executable
         return entry[1][0][3] # Executable?
 
-    def is_executable(self, file_id, path=None):
+    def is_executable(self, path, file_id=None):
         """Test if a file is executable or not.
 
         Note: The caller is expected to take a read-lock before calling this.
@@ -504,8 +501,6 @@
             return entry[1][0][3]
         else:
             self._must_be_locked()
-            if not path:
-                path = self.id2path(file_id)
             mode = osutils.lstat(self.abspath(path)).st_mode
             return bool(stat.S_ISREG(mode) and stat.S_IEXEC & mode)
 
@@ -550,7 +545,7 @@
                 continue
             relpath = pathjoin(key[0].decode('utf8'), key[1].decode('utf8'))
             try:
-                if self._kind(relpath) == 'tree-reference':
+                if self.kind(relpath) == 'tree-reference':
                     yield relpath, key[2]
             except errors.NoSuchFile:
                 # path is missing on disk.
@@ -562,21 +557,7 @@
         entry = self._get_entry(file_id=file_id, path=path)
         state._observed_sha1(entry, *sha_and_stat)
 
-    def kind(self, file_id):
-        """Return the kind of a file.
-
-        This is always the actual kind that's on disk, regardless of what it
-        was added as.
-
-        Note: The caller is expected to take a read-lock before calling this.
-        """
-        relpath = self.id2path(file_id)
-        if relpath is None:
-            raise AssertionError(
-                "path for id {%s} is None!" % file_id)
-        return self._kind(relpath)
-
-    def _kind(self, relpath):
+    def kind(self, relpath, file_id=None):
         abspath = self.abspath(relpath)
         kind = file_kind(abspath)
         if (self._repo_supports_tree_reference and kind == 'directory'):
@@ -1206,20 +1187,27 @@
         finally:
             self.branch.unlock()
 
-    def unversion(self, file_ids):
-        """Remove the file ids in file_ids from the current versioned set.
+    def unversion(self, paths, file_ids=None):
+        """Remove the file ids in paths from the current versioned set.
 
         When a file_id is unversioned, all of its children are automatically
         unversioned.
 
-        :param file_ids: The file ids to stop versioning.
+        :param paths: The file ids to stop versioning.
         :raises: NoSuchId if any fileid is not currently versioned.
         """
         with self.lock_tree_write():
-            if not file_ids:
+            if not paths:
                 return
             state = self.current_dirstate()
             state._read_dirblocks_if_needed()
+            if file_ids is None:
+                file_ids = set()
+                for path in paths:
+                    file_id = self.path2id(path)
+                    if file_id is None:
+                        raise errors.NoSuchFile(self, path)
+                    file_ids.add(file_id)
             ids_to_unversion = set(file_ids)
             paths_to_unversion = set()
             # sketch:
@@ -1705,10 +1693,12 @@
         return "<%s of %s in %s>" % \
             (self.__class__.__name__, self._revision_id, self._dirstate)
 
-    def annotate_iter(self, file_id,
+    def annotate_iter(self, path, file_id=None,
                       default_revision=_mod_revision.CURRENT_REVISION):
         """See Tree.annotate_iter"""
-        text_key = (file_id, self.get_file_revision(file_id))
+        if file_id is None:
+            file_id = self.path2id(path)
+        text_key = (file_id, self.get_file_revision(path, file_id))
         annotations = self._repository.texts.annotate(text_key)
         return [(key[-1], line) for (key, line) in annotations]
 
@@ -1851,7 +1841,7 @@
                 parent_ie.children[name_unicode] = inv_entry
         self._inventory = inv
 
-    def get_file_mtime(self, file_id, path=None):
+    def get_file_mtime(self, path, file_id=None):
         """Return the modification time for this record.
 
         We return the timestamp of the last-changed revision.
@@ -1859,7 +1849,7 @@
         # Make sure the file exists
         entry = self._get_entry(file_id, path=path)
         if entry == (None, None): # do we raise?
-            raise errors.NoSuchId(self, file_id)
+            raise errors.NoSuchFile(path)
         parent_index = self._get_parent_index()
         last_changed_revision = entry[1][parent_index][4]
         try:
@@ -1868,7 +1858,7 @@
             raise FileTimestampUnavailable(self.id2path(file_id))
         return rev.timestamp
 
-    def get_file_sha1(self, file_id, path=None, stat_value=None):
+    def get_file_sha1(self, path, file_id=None, stat_value=None):
         entry = self._get_entry(file_id=file_id, path=path)
         parent_index = self._get_parent_index()
         parent_details = entry[1][parent_index]
@@ -1876,20 +1866,22 @@
             return parent_details[1]
         return None
 
-    def get_file_revision(self, file_id):
+    def get_file_revision(self, path, file_id=None):
         with self.lock_read():
-            inv, inv_file_id = self._unpack_file_id(file_id)
+            inv, inv_file_id = self._path2inv_file_id(path, file_id)
             return inv[inv_file_id].revision
 
-    def get_file(self, file_id, path=None):
-        return BytesIO(self.get_file_text(file_id))
+    def get_file(self, path, file_id=None):
+        return BytesIO(self.get_file_text(path, file_id))
 
-    def get_file_size(self, file_id):
+    def get_file_size(self, path, file_id=None):
         """See Tree.get_file_size"""
-        inv, inv_file_id = self._unpack_file_id(file_id)
+        inv, inv_file_id = self._path2inv_file_id(path, file_id)
         return inv[inv_file_id].text_size
 
-    def get_file_text(self, file_id, path=None):
+    def get_file_text(self, path, file_id=None):
+        if file_id is None:
+            file_id = self.path2id(path)
         content = None
         for _, content_iter in self.iter_files_bytes([(file_id, None)]):
             if content is not None:
@@ -1903,8 +1895,8 @@
                 ' the requested data')
         return content
 
-    def get_reference_revision(self, file_id, path=None):
-        inv, inv_file_id = self._unpack_file_id(file_id)
+    def get_reference_revision(self, path, file_id=None):
+        inv, inv_file_id = self._path2inv_file_id(path, file_id)
         return inv[inv_file_id].reference_revision
 
     def iter_files_bytes(self, desired_files):
@@ -1921,8 +1913,10 @@
                                        identifier))
         return self._repository.iter_files_bytes(repo_desired_files)
 
-    def get_symlink_target(self, file_id, path=None):
-        entry = self._get_entry(file_id=file_id)
+    def get_symlink_target(self, path, file_id=None):
+        entry = self._get_entry(file_id=file_id, path=path)
+        if entry is None:
+            raise errors.NoSuchId(tree=self, file_id=file_id)
         parent_index = self._get_parent_index()
         if entry[1][parent_index][0] != b'l':
             return None
@@ -1952,16 +1946,16 @@
     def has_filename(self, filename):
         return bool(self.path2id(filename))
 
-    def kind(self, file_id):
-        entry = self._get_entry(file_id=file_id)[1]
+    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)
         parent_index = self._get_parent_index()
         return dirstate.DirState._minikind_to_kind[entry[parent_index][0]]
 
-    def stored_kind(self, file_id):
+    def stored_kind(self, path, file_id=None):
         """See Tree.stored_kind"""
-        return self.kind(file_id)
+        return self.kind(path, file_id)
 
     def path_content_summary(self, path):
         """See Tree.path_content_summary."""
@@ -1977,8 +1971,8 @@
         else:
             return (kind, None, None, None)
 
-    def is_executable(self, file_id, path=None):
-        inv, inv_file_id = self._unpack_file_id(file_id)
+    def is_executable(self, path, file_id=None):
+        inv, inv_file_id = self._path2inv_file_id(path, file_id)
         ie = inv[inv_file_id]
         if ie.kind != "file":
             return False

=== modified file 'breezy/commit.py'
--- breezy/commit.py	2017-08-07 21:57:48 +0000
+++ breezy/commit.py	2017-11-19 19:02:26 +0000
@@ -459,7 +459,9 @@
         # Make the working tree be up to date with the branch. This
         # includes automatic changes scheduled to be made to the tree, such
         # as updating its basis and unversioning paths that were missing.
-        self.work_tree.unversion(self.deleted_ids)
+        self.work_tree.unversion(
+                {self.work_tree.id2path(file_id) for file_id in self.deleted_ids},
+                self.deleted_ids)
         self._set_progress_stage("Updating the working tree")
         self.work_tree.update_basis_by_delta(self.rev_id,
              self.builder.get_basis_delta())
@@ -742,7 +744,7 @@
 
     def _commit_nested_tree(self, file_id, path):
         "Commit a nested tree."
-        sub_tree = self.work_tree.get_nested_tree(file_id, path)
+        sub_tree = self.work_tree.get_nested_tree(path, file_id)
         # FIXME: be more comprehensive here:
         # this works when both trees are in --trees repository,
         # but when both are bound to a different repository,
@@ -763,7 +765,7 @@
                 strict=self.strict, verbose=self.verbose,
                 local=self.local, reporter=self.reporter)
         except PointlessCommit:
-            return self.work_tree.get_reference_revision(file_id)
+            return self.work_tree.get_reference_revision(path, file_id)
 
     def _set_progress_stage(self, name, counter=False):
         """Set the progress stage and emit an update to the progress bar."""

=== modified file 'breezy/conflicts.py'
--- breezy/conflicts.py	2017-09-26 00:55:04 +0000
+++ breezy/conflicts.py	2017-11-19 19:02:26 +0000
@@ -513,8 +513,9 @@
             raise AssertionError('bad winner: %r' % (winner,))
         if path_to_create is not None:
             tid = tt.trans_id_tree_path(path_to_create)
+            tree = self._revision_tree(tt._tree, revid)
             transform.create_from_tree(
-                tt, tid, self._revision_tree(tt._tree, revid), file_id)
+                tt, tid, tree, tree.id2path(file_id), file_id=file_id)
             tt.version_file(file_id, tid)
         else:
             tid = tt.trans_id_file_id(file_id)

=== modified file 'breezy/diff.py'
--- breezy/diff.py	2017-11-12 13:53:51 +0000
+++ breezy/diff.py	2017-11-19 19:02:26 +0000
@@ -482,7 +482,7 @@
 def _patch_header_date(tree, file_id, path):
     """Returns a timestamp suitable for use in a patch header."""
     try:
-        mtime = tree.get_file_mtime(file_id, path)
+        mtime = tree.get_file_mtime(path, file_id)
     except FileTimestampUnavailable:
         mtime = 0
     return timestamp.format_patch_date(mtime)
@@ -602,13 +602,13 @@
         if 'symlink' not in (old_kind, new_kind):
             return self.CANNOT_DIFF
         if old_kind == 'symlink':
-            old_target = self.old_tree.get_symlink_target(file_id)
+            old_target = self.old_tree.get_symlink_target(old_path, file_id)
         elif old_kind is None:
             old_target = None
         else:
             return self.CANNOT_DIFF
         if new_kind == 'symlink':
-            new_target = self.new_tree.get_symlink_target(file_id)
+            new_target = self.new_tree.get_symlink_target(new_path, file_id)
         elif new_kind is None:
             new_target = None
         else:
@@ -670,26 +670,27 @@
             return self.CANNOT_DIFF
         from_label = '%s%s\t%s' % (self.old_label, old_path, old_date)
         to_label = '%s%s\t%s' % (self.new_label, new_path, new_date)
-        return self.diff_text(from_file_id, to_file_id, from_label, to_label,
-            old_path, new_path)
+        return self.diff_text(old_path, new_path, from_label, to_label,
+            from_file_id, to_file_id)
 
-    def diff_text(self, from_file_id, to_file_id, from_label, to_label,
-        from_path=None, to_path=None):
+    def diff_text(self, from_path, to_path, from_label, to_label,
+        from_file_id=None, to_file_id=None):
         """Diff the content of given files in two trees
 
-        :param from_file_id: The id of the file in the from tree.  If None,
+        :param from_path: The path in the from tree. If None,
             the file is not present in the from tree.
-        :param to_file_id: The id of the file in the to tree.  This may refer
-            to a different file from from_file_id.  If None,
+        :param to_path: The path in the to tree. This may refer
+            to a different file from from_path.  If None,
             the file is not present in the to tree.
-        :param from_path: The path in the from tree or None if unknown.
-        :param to_path: The path in the to tree or None if unknown.
+        :param from_file_id: The id of the file in the from tree or None if
+            unknown.
+        :param to_file_id: The id of the file in the to tree or None if
+            unknown.
         """
         def _get_text(tree, file_id, path):
-            if file_id is not None:
-                return tree.get_file_lines(file_id, path)
-            else:
+            if file_id is None:
                 return []
+            return tree.get_file_lines(path, file_id)
         try:
             from_text = _get_text(self.old_tree, from_file_id, from_path)
             to_text = _get_text(self.new_tree, to_file_id, to_path)
@@ -797,10 +798,10 @@
         relpath_tmp = relpath_tmp.replace(u'?', u'_')
         return osutils.pathjoin(self._root, prefix, relpath_tmp)
 
-    def _write_file(self, file_id, tree, prefix, relpath, force_temp=False,
-                    allow_write=False):
+    def _write_file(self, relpath, tree, prefix, force_temp=False,
+                    allow_write=False, file_id=None):
         if not force_temp and isinstance(tree, WorkingTree):
-            full_path = tree.abspath(tree.id2path(file_id))
+            full_path = tree.abspath(relpath)
             if self._is_safepath(full_path):
                 return full_path
 
@@ -813,7 +814,7 @@
         except OSError as e:
             if e.errno != errno.EEXIST:
                 raise
-        source = tree.get_file(file_id, relpath)
+        source = tree.get_file(relpath, file_id)
         try:
             target = open(full_path, 'wb')
             try:
@@ -823,7 +824,7 @@
         finally:
             source.close()
         try:
-            mtime = tree.get_file_mtime(file_id)
+            mtime = tree.get_file_mtime(relpath, file_id)
         except FileTimestampUnavailable:
             pass
         else:
@@ -832,12 +833,12 @@
             osutils.make_readonly(full_path)
         return full_path
 
-    def _prepare_files(self, file_id, old_path, new_path, force_temp=False,
-                       allow_write_new=False):
-        old_disk_path = self._write_file(file_id, self.old_tree, 'old',
-                                         old_path, force_temp)
-        new_disk_path = self._write_file(file_id, self.new_tree, 'new',
-                                         new_path, force_temp,
+    def _prepare_files(self, old_path, new_path, force_temp=False,
+                       allow_write_new=False, file_id=None):
+        old_disk_path = self._write_file(old_path, self.old_tree, 'old',
+                                         force_temp, file_id=file_id)
+        new_disk_path = self._write_file(new_path, self.new_tree, 'new',
+                                         force_temp, file_id=file_id,
                                          allow_write=allow_write_new)
         return old_disk_path, new_disk_path
 
@@ -853,10 +854,10 @@
         if (old_kind, new_kind) != ('file', 'file'):
             return DiffPath.CANNOT_DIFF
         (old_disk_path, new_disk_path) = self._prepare_files(
-                                                file_id, old_path, new_path)
+                old_path, new_path, file_id=file_id)
         self._execute(old_disk_path, new_disk_path)
 
-    def edit_file(self, file_id):
+    def edit_file(self, old_path, new_path, file_id=None):
         """Use this tool to edit a file.
 
         A temporary copy will be edited, and the new contents will be
@@ -865,12 +866,9 @@
         :param file_id: The id of the file to edit.
         :return: The new contents of the file.
         """
-        old_path = self.old_tree.id2path(file_id)
-        new_path = self.new_tree.id2path(file_id)
         old_abs_path, new_abs_path = self._prepare_files(
-                                            file_id, old_path, new_path,
-                                            allow_write_new=True,
-                                            force_temp=True)
+                old_path, new_path, allow_write_new=True, force_temp=True,
+                file_id=file_id)
         command = self._get_command(old_abs_path, new_abs_path)
         subprocess.call(command, cwd=self._root)
         new_file = open(new_abs_path, 'rb')
@@ -1025,7 +1023,7 @@
                 self.to_file.write("=== modified %s '%s'%s\n" % (kind[0],
                                    newpath_encoded, prop_str))
             if changed_content:
-                self._diff(file_id, oldpath, newpath, kind[0], kind[1])
+                self._diff(oldpath, newpath, kind[0], kind[1], file_id=file_id)
                 has_changes = 1
             if renamed:
                 has_changes = 1
@@ -1038,18 +1036,17 @@
         :param old_path: The path of the file in the old tree
         :param new_path: The path of the file in the new tree
         """
-        try:
-            old_kind = self.old_tree.kind(file_id)
-        except (errors.NoSuchId, errors.NoSuchFile):
+        if old_path is None:
             old_kind = None
-        try:
-            new_kind = self.new_tree.kind(file_id)
-        except (errors.NoSuchId, errors.NoSuchFile):
+        else:
+            old_kind = self.old_tree.kind(old_path, file_id)
+        if new_path is None:
             new_kind = None
-        self._diff(file_id, old_path, new_path, old_kind, new_kind)
-
-
-    def _diff(self, file_id, old_path, new_path, old_kind, new_kind):
+        else:
+            new_kind = self.new_tree.kind(new_path, file_id)
+        self._diff(old_path, new_path, old_kind, new_kind, file_id=file_id)
+
+    def _diff(self, old_path, new_path, old_kind, new_kind, file_id):
         result = DiffPath._diff_many(self.differs, file_id, old_path,
                                        new_path, old_kind, new_kind)
         if result is DiffPath.CANNOT_DIFF:

=== modified file 'breezy/export/dir_exporter.py'
--- breezy/export/dir_exporter.py	2017-05-22 00:56:52 +0000
+++ breezy/export/dir_exporter.py	2017-11-19 19:02:26 +0000
@@ -62,7 +62,7 @@
             os.mkdir(fullpath)
         elif ie.kind == "symlink":
             try:
-                symlink_target = tree.get_symlink_target(ie.file_id, tp)
+                symlink_target = tree.get_symlink_target(tp, ie.file_id)
                 os.symlink(symlink_target, fullpath)
             except OSError as e:
                 raise errors.BzrError(
@@ -80,7 +80,7 @@
         fullpath = osutils.pathjoin(dest, relpath)
         # We set the mode and let the umask sort out the file info
         mode = 0o666
-        if tree.is_executable(file_id, treepath):
+        if tree.is_executable(treepath, file_id):
             mode = 0o777
         out = os.fdopen(os.open(fullpath, flags, mode), 'wb')
         try:
@@ -90,7 +90,7 @@
         if force_mtime is not None:
             mtime = force_mtime
         else:
-            mtime = tree.get_file_mtime(file_id, treepath)
+            mtime = tree.get_file_mtime(treepath, file_id)
         os.utime(fullpath, (mtime, mtime))
 
         yield

=== modified file 'breezy/export/tar_exporter.py'
--- breezy/export/tar_exporter.py	2017-05-22 00:56:52 +0000
+++ breezy/export/tar_exporter.py	2017-11-19 19:02:26 +0000
@@ -49,10 +49,10 @@
     if force_mtime is not None:
         item.mtime = force_mtime
     else:
-        item.mtime = tree.get_file_mtime(entry.file_id, tree_path)
+        item.mtime = tree.get_file_mtime(tree_path, entry.file_id)
     if entry.kind == "file":
         item.type = tarfile.REGTYPE
-        if tree.is_executable(entry.file_id, tree_path):
+        if tree.is_executable(tree_path, entry.file_id):
             item.mode = 0o755
         else:
             item.mode = 0o644
@@ -60,7 +60,7 @@
         # the tarfile contract, which wants the size of the file up front.  We
         # want to make sure it doesn't change, and we need to read it in one
         # go for content filtering.
-        content = tree.get_file_text(entry.file_id, tree_path)
+        content = tree.get_file_text(tree_path, entry.file_id)
         item.size = len(content)
         fileobj = BytesIO(content)
     elif entry.kind == "directory":
@@ -73,7 +73,7 @@
         item.type = tarfile.SYMTYPE
         item.size = 0
         item.mode = 0o755
-        item.linkname = tree.get_symlink_target(entry.file_id, tree_path)
+        item.linkname = tree.get_symlink_target(tree_path, entry.file_id)
         fileobj = None
     else:
         raise errors.BzrError("don't know how to export {%s} of kind %r"
@@ -124,7 +124,7 @@
         rev = tree.repository.get_revision(tree.get_revision_id())
         root_mtime = rev.timestamp
     elif tree.get_root_id() is not None:
-        root_mtime = tree.get_file_mtime(tree.get_root_id())
+        root_mtime = tree.get_file_mtime('', tree.get_root_id())
     else:
         root_mtime = None
 

=== modified file 'breezy/export/zip_exporter.py'
--- breezy/export/zip_exporter.py	2017-05-22 00:56:52 +0000
+++ breezy/export/zip_exporter.py	2017-11-19 19:02:26 +0000
@@ -66,7 +66,7 @@
             if force_mtime is not None:
                 mtime = force_mtime
             else:
-                mtime = tree.get_file_mtime(ie.file_id, tp)
+                mtime = tree.get_file_mtime(tp, ie.file_id)
             date_time = time.localtime(mtime)[:6]
             filename = osutils.pathjoin(root, dp).encode('utf8')
             if ie.kind == "file":
@@ -75,7 +75,7 @@
                             date_time=date_time)
                 zinfo.compress_type = compression
                 zinfo.external_attr = _FILE_ATTR
-                content = tree.get_file_text(file_id, tp)
+                content = tree.get_file_text(tp, file_id)
                 zipf.writestr(zinfo, content)
             elif ie.kind == "directory":
                 # Directories must contain a trailing slash, to indicate
@@ -93,7 +93,7 @@
                             date_time=date_time)
                 zinfo.compress_type = compression
                 zinfo.external_attr = _FILE_ATTR
-                zipf.writestr(zinfo, tree.get_symlink_target(file_id, tp))
+                zipf.writestr(zinfo, tree.get_symlink_target(tp, file_id))
             yield
 
         zipf.close()

=== modified file 'breezy/fetch.py'
--- breezy/fetch.py	2017-06-08 23:30:31 +0000
+++ breezy/fetch.py	2017-11-19 19:02:26 +0000
@@ -217,7 +217,7 @@
         revision_root = {}
         for tree in self.iter_rev_trees(revs):
             root_id = tree.get_root_id()
-            revision_id = tree.get_file_revision(root_id, u"")
+            revision_id = tree.get_file_revision(u'', root_id)
             revision_root[revision_id] = root_id
         # Find out which parents we don't already know root ids for
         parents = set(viewvalues(parent_map))
@@ -323,7 +323,7 @@
                 pass
             else:
                 try:
-                    parent_ids.append(tree.get_file_revision(root_id))
+                    parent_ids.append(tree.get_file_revision(u'', root_id))
                 except errors.NoSuchId:
                     # not in the tree
                     pass

=== modified file 'breezy/filter_tree.py'
--- breezy/filter_tree.py	2017-05-22 00:56:52 +0000
+++ breezy/filter_tree.py	2017-11-19 19:02:26 +0000
@@ -44,10 +44,8 @@
         self.backing_tree = backing_tree
         self.filter_stack_callback = filter_stack_callback
 
-    def get_file_text(self, file_id, path=None):
-        chunks = self.backing_tree.get_file_lines(file_id, path)
-        if path is None:
-            path = self.backing_tree.id2path(file_id)
+    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)
         contents = filtered_output_bytes(chunks, filters, context)
@@ -57,8 +55,8 @@
     def has_filename(self, filename):
         return self.backing_tree.has_filename
 
-    def is_executable(self, file_id, path=None):
-        return self.backing_tree.is_executable(file_id, path)
+    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):
         # NB: This simply returns the parent tree's entries; the length may be

=== modified file 'breezy/lockable_files.py'
--- breezy/lockable_files.py	2017-08-27 17:24:34 +0000
+++ breezy/lockable_files.py	2017-11-19 19:02:26 +0000
@@ -292,7 +292,7 @@
     def create(self, mode=None):
         """Create lock mechanism"""
         # for old-style locks, create the file now
-        self._transport.put_bytes(self._escaped_name, '',
+        self._transport.put_bytes(self._escaped_name, b'',
                             mode=self._file_modebits)
 
     def validate_token(self, token):

=== modified file 'breezy/log.py'
--- breezy/log.py	2017-11-12 13:53:51 +0000
+++ breezy/log.py	2017-11-19 19:02:26 +0000
@@ -2062,7 +2062,7 @@
         tree1 = None
         for fp in relpaths:
             file_id = tree.path2id(fp)
-            kind = _get_kind_for_file_id(tree, file_id)
+            kind = _get_kind_for_file_id(tree, fp, file_id)
             if file_id is None:
                 # go back to when time began
                 if tree1 is None:
@@ -2076,7 +2076,7 @@
                         tree1 = b.repository.revision_tree(rev1)
                 if tree1:
                     file_id = tree1.path2id(fp)
-                    kind = _get_kind_for_file_id(tree1, file_id)
+                    kind = _get_kind_for_file_id(tree1, fp, file_id)
             info_list.append((fp, file_id, kind))
 
     elif start_rev_info == end_rev_info:
@@ -2084,7 +2084,7 @@
         tree = b.repository.revision_tree(end_rev_info.rev_id)
         for fp in relpaths:
             file_id = tree.path2id(fp)
-            kind = _get_kind_for_file_id(tree, file_id)
+            kind = _get_kind_for_file_id(tree, fp, file_id)
             info_list.append((fp, file_id, kind))
 
     else:
@@ -2098,7 +2098,7 @@
         tree1 = None
         for fp in relpaths:
             file_id = tree.path2id(fp)
-            kind = _get_kind_for_file_id(tree, file_id)
+            kind = _get_kind_for_file_id(tree, fp, file_id)
             if file_id is None:
                 if tree1 is None:
                     rev_id = start_rev_info.rev_id
@@ -2108,15 +2108,15 @@
                     else:
                         tree1 = b.repository.revision_tree(rev_id)
                 file_id = tree1.path2id(fp)
-                kind = _get_kind_for_file_id(tree1, file_id)
+                kind = _get_kind_for_file_id(tree1, fp, file_id)
             info_list.append((fp, file_id, kind))
     return b, info_list, start_rev_info, end_rev_info
 
 
-def _get_kind_for_file_id(tree, file_id):
+def _get_kind_for_file_id(tree, path, file_id):
     """Return the kind of a file-id or None if it doesn't exist."""
     if file_id is not None:
-        return tree.kind(file_id)
+        return tree.kind(path, file_id)
     else:
         return None
 

=== modified file 'breezy/memorytree.py'
--- breezy/memorytree.py	2017-08-29 14:45:14 +0000
+++ breezy/memorytree.py	2017-11-19 19:02:26 +0000
@@ -85,16 +85,12 @@
         missing files, so is a no-op.
         """
 
-    def get_file(self, file_id, path=None):
+    def get_file(self, path, file_id=None):
         """See Tree.get_file."""
-        if path is None:
-            path = self.id2path(file_id)
         return self._file_transport.get(path)
 
-    def get_file_sha1(self, file_id, path=None, stat_value=None):
+    def get_file_sha1(self, path, file_id=None, stat_value=None):
         """See Tree.get_file_sha1()."""
-        if path is None:
-            path = self.id2path(file_id)
         stream = self._file_transport.get(path)
         return sha_file(stream)
 
@@ -120,7 +116,7 @@
         id = self.path2id(path)
         if id is None:
             return 'missing', None, None, None
-        kind = self.kind(id)
+        kind = self.kind(path, id)
         if kind == 'file':
             bytes = self._file_transport.get_bytes(path)
             size = len(bytes)
@@ -154,10 +150,12 @@
         """See Tree.has_filename()."""
         return self._file_transport.has(filename)
 
-    def is_executable(self, file_id, path=None):
+    def is_executable(self, path, file_id=None):
         return self._inventory[file_id].executable
 
-    def kind(self, file_id):
+    def kind(self, path, file_id=None):
+        if file_id is None:
+            file_id = self.path2id(path)
         return self._inventory[file_id].kind
 
     def mkdir(self, path, file_id=None):
@@ -238,13 +236,13 @@
                 self._file_transport.mkdir(path)
             elif entry.kind == 'file':
                 self._file_transport.put_file(path,
-                    self._basis_tree.get_file(entry.file_id))
+                    self._basis_tree.get_file(path, entry.file_id))
             else:
                 raise NotImplementedError(self._populate_from_branch)
 
-    def put_file_bytes_non_atomic(self, file_id, bytes):
+    def put_file_bytes_non_atomic(self, path, bytes, file_id=None):
         """See MutableTree.put_file_bytes_non_atomic."""
-        self._file_transport.put_bytes(self.id2path(file_id), bytes)
+        self._file_transport.put_bytes(path, bytes)
 
     def unlock(self):
         """Release a lock.
@@ -264,19 +262,21 @@
         else:
             self._locks -= 1
 
-    def unversion(self, file_ids):
-        """Remove the file ids in file_ids from the current versioned set.
+    def unversion(self, paths, file_ids=None):
+        """Remove the paths from the current versioned set.
 
         When a file_id is unversioned, all of its children are automatically
         unversioned.
 
-        :param file_ids: The file ids to stop versioning.
+        :param paths: The paths to stop versioning.
         :raises: NoSuchId if any fileid is not currently versioned.
         """
         with self.lock_tree_write():
             # XXX: This should be in mutabletree, but the inventory-save action
             # 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}
             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	2017-07-30 16:59:50 +0000
+++ breezy/merge.py	2017-11-19 19:02:26 +0000
@@ -651,9 +651,9 @@
             hook(merge)
         if self.recurse == 'down':
             for relpath, file_id in self.this_tree.iter_references():
-                sub_tree = self.this_tree.get_nested_tree(file_id, relpath)
+                sub_tree = self.this_tree.get_nested_tree(relpath, file_id)
                 other_revision = self.other_tree.get_reference_revision(
-                    file_id, relpath)
+                    relpath, file_id)
                 if  other_revision == sub_tree.last_revision():
                     continue
                 sub_merge = Merger(sub_tree.branch, this_tree=sub_tree)
@@ -661,7 +661,9 @@
                 other_branch = self.other_branch.reference_parent(file_id,
                                                                   relpath)
                 sub_merge.set_other_revision(other_revision, other_branch)
-                base_revision = self.base_tree.get_reference_revision(file_id)
+                base_tree_path = self.base_tree.id2path(file_id)
+                base_revision = self.base_tree.get_reference_revision(
+                    base_tree_path, file_id)
                 sub_merge.base_tree = \
                     sub_tree.branch.repository.revision_tree(base_revision)
                 sub_merge.base_rev_id = base_revision
@@ -1005,7 +1007,7 @@
                     def get_sha1(ie, tree):
                         if ie.kind != 'file':
                             return None
-                        return tree.get_file_sha1(file_id)
+                        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)]
@@ -1028,7 +1030,8 @@
                     def get_target(ie, tree):
                         if ie.kind != 'symlink':
                             return None
-                        return tree.get_symlink_target(file_id)
+                        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)]
@@ -1069,10 +1072,11 @@
     def write_modified(self, results):
         modified_hashes = {}
         for path in results.modified_paths:
-            file_id = self.working_tree.path2id(self.working_tree.relpath(path))
+            wt_relpath = self.working_tree.relpath(path)
+            file_id = self.working_tree.path2id(wt_relpath)
             if file_id is None:
                 continue
-            hash = self.working_tree.get_file_sha1(file_id)
+            hash = self.working_tree.get_file_sha1(wt_relpath, file_id)
             if hash is None:
                 continue
             modified_hashes[file_id] = hash
@@ -1095,25 +1099,31 @@
     @staticmethod
     def contents_sha1(tree, file_id):
         """Determine the sha1 of the file contents (used as a key method)."""
-        if not tree.has_id(file_id):
+        try:
+            path = tree.id2path(file_id)
+        except errors.NoSuchId:
             return None
-        return tree.get_file_sha1(file_id)
+        return tree.get_file_sha1(path, file_id)
 
     @staticmethod
     def executable(tree, file_id):
         """Determine the executability of a file-id (used as a key method)."""
-        if not tree.has_id(file_id):
+        try:
+            path = tree.id2path(file_id)
+        except errors.NoSuchId:
             return None
-        if tree.kind(file_id) != "file":
+        if tree.kind(path, file_id) != "file":
             return False
-        return tree.is_executable(file_id)
+        return tree.is_executable(path, file_id)
 
     @staticmethod
-    def kind(tree, file_id):
+    def kind(tree, path, file_id):
         """Determine the kind of a file-id (used as a key method)."""
-        if not tree.has_id(file_id):
+        try:
+            path = tree.id2path(file_id)
+        except errors.NoSuchId:
             return None
-        return tree.kind(file_id)
+        return tree.kind(path, file_id)
 
     @staticmethod
     def _three_way(base, other, this):
@@ -1251,13 +1261,18 @@
     def _do_merge_contents(self, file_id):
         """Performs a merge on file_id contents."""
         def contents_pair(tree):
-            if not tree.has_id(file_id):
-                return (None, None)
-            kind = tree.kind(file_id)
+            try:
+                path = tree.id2path(file_id)
+            except errors.NoSuchId:
+                return (None, None)
+            try:
+                kind = tree.kind(path, file_id)
+            except errors.NoSuchFile:
+                return (None, None)
             if kind == "file":
-                contents = tree.get_file_sha1(file_id)
+                contents = tree.get_file_sha1(path, file_id)
             elif kind == "symlink":
-                contents = tree.get_symlink_target(file_id)
+                contents = tree.get_symlink_target(path, file_id)
             else:
                 contents = None
             return kind, contents
@@ -1319,7 +1334,8 @@
                     # conflict
                     self.tt.version_file(file_id, trans_id)
                     transform.create_from_tree(
-                        self.tt, trans_id, self.other_tree, file_id,
+                        self.tt, trans_id, self.other_tree,
+                        self.other_tree.id2path(file_id), 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
@@ -1377,7 +1393,8 @@
         if self.other_tree.has_id(file_id):
             # OTHER changed the file
             transform.create_from_tree(
-                self.tt, trans_id, self.other_tree, file_id,
+                self.tt, trans_id, self.other_tree,
+                self.other_tree.id2path(file_id), 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):
@@ -1411,20 +1428,26 @@
 
     def get_lines(self, tree, file_id):
         """Return the lines in a file, or an empty list."""
-        if tree.has_id(file_id):
-            return tree.get_file_lines(file_id)
-        else:
+        try:
+            path = tree.id2path(file_id)
+        except errors.NoSuchId:
             return []
+        else:
+            return tree.get_file_lines(path, file_id)
 
     def text_merge(self, file_id, trans_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.
-        if self.base_tree.has_id(file_id) and \
-            self.base_tree.kind(file_id) == "file":
-            base_lines = self.get_lines(self.base_tree, file_id)
-        else:
+        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)
         m3 = merge3.Merge3(base_lines, this_lines, other_lines,
@@ -1503,22 +1526,29 @@
         versioned = False
         file_group = []
         for suffix, tree, lines in data:
-            if tree.has_id(file_id):
-                trans_id = self._conflict_file(name, parent_id, tree, file_id,
-                                               suffix, lines, filter_tree_path)
+            try:
+                path = tree.id2path(file_id)
+            except errors.NoSuchId:
+                pass
+            else:
+                trans_id = self._conflict_file(
+                        name, parent_id, path, tree, file_id, suffix, lines,
+                        filter_tree_path)
                 file_group.append(trans_id)
                 if set_version and not versioned:
                     self.tt.version_file(file_id, trans_id)
                     versioned = True
         return file_group
 
-    def _conflict_file(self, name, parent_id, tree, file_id, suffix,
+    def _conflict_file(self, name, parent_id, path, tree, file_id, suffix,
                        lines=None, filter_tree_path=None):
         """Emit a single conflict file."""
         name = name + '.' + suffix
         trans_id = self.tt.create_path(name, parent_id)
-        transform.create_from_tree(self.tt, trans_id, tree, file_id, lines,
-            filter_tree_path)
+        transform.create_from_tree(
+                self.tt, trans_id, tree, path,
+                file_id=file_id, bytes=lines,
+                filter_tree_path=filter_tree_path)
         return trans_id
 
     def merge_executable(self, file_id, file_status):
@@ -1702,7 +1732,7 @@
         out_path = osutils.pathjoin(temp_dir, name)
         out_file = open(out_path, "wb")
         try:
-            in_file = tree.get_file(file_id)
+            in_file = tree.get_file(tree.id2path(file_id), file_id)
             for line in in_file:
                 out_file.write(line)
         finally:
@@ -1852,10 +1882,10 @@
         try:
             entries = self._entries_to_incorporate()
             entries = list(entries)
-            for num, (entry, parent_id) in enumerate(entries):
+            for num, (entry, parent_id, path) in enumerate(entries):
                 child_pb.update(gettext('Preparing file merge'), num, len(entries))
                 parent_trans_id = self.tt.trans_id_file_id(parent_id)
-                trans_id = transform.new_by_entry(self.tt, entry,
+                trans_id = transform.new_by_entry(path, self.tt, entry,
                     parent_trans_id, self.other_tree)
         finally:
             child_pb.finished()
@@ -1887,17 +1917,17 @@
             # an edge case, so we don't do anything special for those.  We let
             # them cause conflicts.
             merge_into_root.file_id = generate_ids.gen_file_id(name_in_target)
-        yield (merge_into_root, target_id)
+        yield (merge_into_root, target_id, '')
         if subdir.kind != 'directory':
             # No children, so we are done.
             return
-        for ignored_path, entry in other_inv.iter_entries_by_dir(subdir_id):
+        for path, entry in other_inv.iter_entries_by_dir(subdir_id):
             parent_id = entry.parent_id
             if parent_id == subdir.file_id:
                 # The root's parent ID has changed, so make sure children of
                 # the root refer to the new ID.
                 parent_id = merge_into_root.file_id
-            yield (entry, parent_id)
+            yield (entry, parent_id, path)
 
 
 def merge_inner(this_branch, other_tree, base_tree, ignore_zero=False,

=== modified file 'breezy/mutabletree.py'
--- breezy/mutabletree.py	2017-08-29 21:29:35 +0000
+++ breezy/mutabletree.py	2017-11-19 19:02:26 +0000
@@ -307,7 +307,7 @@
         :return: None
         """
 
-    def put_file_bytes_non_atomic(self, file_id, bytes):
+    def put_file_bytes_non_atomic(self, path, bytes, file_id=None):
         """Update the content of a file in the tree.
 
         Note that the file is written in-place rather than being

=== modified file 'breezy/plugins/commitfromnews/committemplate.py'
--- breezy/plugins/commitfromnews/committemplate.py	2017-07-23 23:43:55 +0000
+++ breezy/plugins/commitfromnews/committemplate.py	2017-11-19 19:02:26 +0000
@@ -69,7 +69,7 @@
             # changed in new version of the file. So for now a direct diff
             # using patiencediff is done.
             old_revision = self.commit.basis_tree.get_file_revision(
-                found_entry.file_id)
+                old_path, found_entry.file_id)
             needed = [(found_entry.file_id, found_entry.revision, 'new'),
                       (found_entry.file_id, old_revision, 'old')]
             contents = self.commit.builder.repository.iter_files_bytes(needed)

=== modified file 'breezy/plugins/fastimport/exporter.py'
--- breezy/plugins/fastimport/exporter.py	2017-09-26 01:06:03 +0000
+++ breezy/plugins/fastimport/exporter.py	2017-11-19 19:02:26 +0000
@@ -294,16 +294,15 @@
             marks_file.export_marks(self.export_marks_file, revision_ids)
 
     def is_empty_dir(self, tree, path):
-        path_id = tree.path2id(path)
-        if path_id is None:
+        # Continue if path is not a directory
+        try:
+            if tree.kind(path) != 'directory':
+                return False
+        except bazErrors.NoSuchFile:
             self.warning("Skipping empty_dir detection - no file_id for %s" %
                 (path,))
             return False
 
-        # Continue if path is not a directory
-        if tree.kind(path_id) != 'directory':
-            return False
-
         # Use treewalk to find the contents of our directory
         contents = list(tree.walkdirs(prefix=path))[0]
         if len(contents[1]) == 0:
@@ -487,19 +486,21 @@
         # Record modifications
         for path, id_, kind in changes.added + my_modified + rd_modifies:
             if kind == 'file':
-                text = tree_new.get_file_text(id_)
+                text = tree_new.get_file_text(path, id_)
                 file_cmds.append(commands.FileModifyCommand(path.encode("utf-8"),
-                    helpers.kind_to_mode('file', tree_new.is_executable(id_)),
+                    helpers.kind_to_mode(
+                        'file', tree_new.is_executable(path, id_)),
                     None, text))
             elif kind == 'symlink':
                 file_cmds.append(commands.FileModifyCommand(path.encode("utf-8"),
                     helpers.kind_to_mode('symlink', False),
-                    None, tree_new.get_symlink_target(id_)))
+                    None, tree_new.get_symlink_target(path, id_)))
             elif kind == 'directory':
                 if not self.plain_format:
-                    file_cmds.append(commands.FileModifyCommand(path.encode("utf-8"),
-                        helpers.kind_to_mode('directory', False),
-                        None, None))
+                    file_cmds.append(
+                            commands.FileModifyCommand(path.encode("utf-8"),
+                                helpers.kind_to_mode('directory', False), None,
+                                None))
             else:
                 self.warning("cannot export '%s' of kind %s yet - ignoring" %
                     (path, kind))
@@ -557,7 +558,7 @@
 
             # Renaming a directory implies all children must be renamed.
             # Note: changes_from() doesn't handle this
-            if kind == 'directory' and tree_old.kind(id_) == 'directory':
+            if kind == 'directory' and tree_old.kind(oldpath, id_) == 'directory':
                 for p, e in tree_old.inventory.iter_entries_by_dir(from_dir=id_):
                     if e.kind == 'directory' and self.plain_format:
                         continue

=== modified file 'breezy/plugins/fastimport/revision_store.py'
--- breezy/plugins/fastimport/revision_store.py	2017-09-26 00:55:04 +0000
+++ breezy/plugins/fastimport/revision_store.py	2017-11-19 19:02:26 +0000
@@ -66,12 +66,14 @@
         # TODO: Handle root renames?
         return self._basis_inv.root.file_id
 
-    def get_file_with_stat(self, file_id, path=None):
-        content = self.get_file_text(file_id, path)
+    def get_file_with_stat(self, path, file_id=None):
+        content = self.get_file_text(path, file_id)
         sio = StringIO(content)
         return sio, None
 
-    def get_file_text(self, file_id, path=None):
+    def get_file_text(self, path, file_id=None):
+        if file_id is None:
+            file_id = self.path2id(path)
         try:
             return self._content_provider(file_id)
         except KeyError:
@@ -83,13 +85,15 @@
                                                         'unordered', True)
             return stream.next().get_bytes_as('fulltext')
 
-    def get_symlink_target(self, file_id):
+    def get_symlink_target(self, path, file_id=None):
+        if file_id is None:
+            file_id = self.path2id(path)
         if file_id in self._new_info_by_id:
             ie = self._new_info_by_id[file_id][1]
             return ie.symlink_target
         return self._basis_inv[file_id].symlink_target
 
-    def get_reference_revision(self, file_id, path=None):
+    def get_reference_revision(self, path, file_id=None):
         raise NotImplementedError(_TreeShim.get_reference_revision)
 
     def _delta_to_iter_changes(self):
@@ -222,12 +226,14 @@
     def get_file_text(self, revision_id, file_id):
         """Get the text stored for a file in a given revision."""
         revtree = self.repo.revision_tree(revision_id)
-        return revtree.get_file_text(file_id)
+        path = revtree.id2path(file_id)
+        return revtree.get_file_text(path, file_id)
 
     def get_file_lines(self, revision_id, file_id):
         """Get the lines stored for a file in a given revision."""
         revtree = self.repo.revision_tree(revision_id)
-        return osutils.split_lines(revtree.get_file_text(file_id))
+        path = revtree.id2path(file_id)
+        return osutils.split_lines(revtree.get_file_text(path, file_id))
 
     def start_new_revision(self, revision, parents, parent_invs):
         """Init the metadata needed for get_parents_and_revision_for_entry().

=== modified file 'breezy/plugins/fastimport/tests/test_generic_processor.py'
--- breezy/plugins/fastimport/tests/test_generic_processor.py	2017-08-26 13:58:53 +0000
+++ breezy/plugins/fastimport/tests/test_generic_processor.py	2017-11-19 19:02:26 +0000
@@ -175,21 +175,20 @@
     def assertContent(self, branch, tree, path, content):
         file_id = tree.path2id(path)
         with branch.lock_read():
-            self.assertEqual(tree.get_file_text(file_id), content)
+            self.assertEqual(tree.get_file_text(path, file_id), content)
 
     def assertSymlinkTarget(self, branch, tree, path, target):
         file_id = tree.path2id(path)
         with branch.lock_read():
-            self.assertEqual(tree.get_symlink_target(file_id), target)
+            self.assertEqual(tree.get_symlink_target(path, file_id), target)
 
     def assertExecutable(self, branch, tree, path, executable):
-        file_id = tree.path2id(path)
         with branch.lock_read():
-            self.assertEqual(tree.is_executable(file_id), executable)
+            self.assertEqual(tree.is_executable(path), executable)
 
     def assertRevisionRoot(self, revtree, path):
         self.assertEqual(revtree.get_revision_id(),
-                         revtree.get_file_revision(revtree.path2id(path)))
+                         revtree.get_file_revision(path))
 
 
 class TestImportToPackTag(TestCaseForGenericProcessor):
@@ -1943,11 +1942,10 @@
         rev_b = branch.repository.get_parent_map([rev_c])[rev_c][0]
         rtree_a, rtree_b, rtree_c, rtree_d = branch.repository.revision_trees([
             rev_a, rev_b, rev_c, rev_d])
-        foo_id = rtree_a.path2id('foo')
-        self.assertEqual(rev_a, rtree_a.get_file_revision(foo_id))
-        self.assertEqual(rev_b, rtree_b.get_file_revision(foo_id))
-        self.assertEqual(rev_c, rtree_c.get_file_revision(foo_id))
-        self.assertEqual(rev_c, rtree_d.get_file_revision(foo_id))
+        self.assertEqual(rev_a, rtree_a.get_file_revision('foo'))
+        self.assertEqual(rev_b, rtree_b.get_file_revision('foo'))
+        self.assertEqual(rev_c, rtree_c.get_file_revision('foo'))
+        self.assertEqual(rev_c, rtree_d.get_file_revision('foo'))
 
 
 class TestCommitCommands(TestCaseForGenericProcessor):
@@ -1987,5 +1985,4 @@
         self.addCleanup(branch.unlock)
         rev_a = branch.last_revision()
         rtree_a = branch.repository.revision_tree(rev_a)
-        foo_id = rtree_a.path2id(u'foo\ufffd')
-        self.assertEqual(rev_a, rtree_a.get_file_revision(foo_id))
+        self.assertEqual(rev_a, rtree_a.get_file_revision(u'foo\ufffd'))

=== modified file 'breezy/plugins/fastimport/tests/test_revision_store.py'
--- breezy/plugins/fastimport/tests/test_revision_store.py	2017-06-08 23:30:31 +0000
+++ breezy/plugins/fastimport/tests/test_revision_store.py	2017-11-19 19:02:26 +0000
@@ -98,7 +98,7 @@
         shim = revision_store._TreeShim(repo=None, basis_inv=basis_inv,
                                         inv_delta=[],
                                         content_provider=content_provider)
-        f_obj, stat_val = shim.get_file_with_stat('baz-id')
+        f_obj, stat_val = shim.get_file_with_stat('bar/baz', 'baz-id')
         self.assertIs(None, stat_val)
         self.assertEqualDiff('content of\nbaz-id\n', f_obj.read())
 
@@ -112,7 +112,8 @@
         basis_inv.add(ie)
         shim = revision_store._TreeShim(repo=None, basis_inv=basis_inv,
                                         inv_delta=[], content_provider=None)
-        self.assertEqual(u'link-target', shim.get_symlink_target('link-id'))
+        self.assertEqual(u'link-target',
+                         shim.get_symlink_target('link', 'link-id'))
 
     def test_get_symlink_target_from_delta(self):
         basis_inv = self.make_trivial_basis_inv()
@@ -122,7 +123,8 @@
         shim = revision_store._TreeShim(repo=None, basis_inv=basis_inv,
                                         inv_delta=inv_delta,
                                         content_provider=None)
-        self.assertEqual(u'link-target', shim.get_symlink_target('link-id'))
+        self.assertEqual(u'link-target',
+                         shim.get_symlink_target('link', 'link-id'))
 
     def test__delta_to_iter_changes(self):
         basis_inv = self.make_trivial_basis_inv()

=== modified file 'breezy/plugins/grep/grep.py'
--- breezy/plugins/grep/grep.py	2017-11-12 13:53:51 +0000
+++ breezy/plugins/grep/grep.py	2017-11-19 19:02:26 +0000
@@ -428,7 +428,7 @@
                 # If old result is valid, print results immediately.
                 # Otherwise, add file info to to_grep so that the
                 # loop later will get chunks and grep them
-                cache_id = tree.get_file_revision(fid)
+                cache_id = tree.get_file_revision(fp, fid)
                 if cache_id in outputter.cache:
                     # GZ 2010-06-05: Not really sure caching and re-outputting
                     #                the old path is really the right thing,
@@ -455,7 +455,7 @@
         for (path, fid), chunks in tree.iter_files_bytes(to_grep):
             path = _make_display_path(relpath, path)
             _file_grep(chunks[0], path, opts, revno, path_prefix,
-                tree.get_file_revision(fid, path))
+                tree.get_file_revision(path, fid))
 
 
 def _make_display_path(relpath, path):
@@ -478,7 +478,7 @@
     """
 
     path = _make_display_path(relpath, path)
-    file_text = tree.get_file_text(id)
+    file_text = tree.get_file_text(relpath, id)
     _file_grep(file_text, path, opts, revno, path_prefix)
 
 

=== modified file 'breezy/plugins/upload/cmds.py'
--- breezy/plugins/upload/cmds.py	2017-11-12 13:53:51 +0000
+++ breezy/plugins/upload/cmds.py	2017-11-19 19:02:26 +0000
@@ -153,12 +153,11 @@
         if self._ignored is None:
             try:
                 ignore_file_path = '.bzrignore-upload'
-                ignore_file_id = self.tree.path2id(ignore_file_path)
-                ignore_file = self.tree.get_file(ignore_file_id,
-                                                 ignore_file_path)
+                ignore_file = self.tree.get_file(ignore_file_path)
+            except errors.NoSuchFile:
+                ignored_patterns = []
+            else:
                 ignored_patterns = ignores.parse_ignore_file(ignore_file)
-            except errors.NoSuchId:
-                ignored_patterns = []
             self._ignored = globbing.Globster(ignored_patterns)
         return self._ignored
 
@@ -177,13 +176,13 @@
 
     def upload_file(self, relpath, id, mode=None):
         if mode is None:
-            if self.tree.is_executable(id):
+            if self.tree.is_executable(relpath, id):
                 mode = 0o775
             else:
                 mode = 0o664
         if not self.quiet:
             self.outf.write('Uploading %s\n' % relpath)
-        self._up_put_bytes(relpath, self.tree.get_file_text(id), mode)
+        self._up_put_bytes(relpath, self.tree.get_file_text(relpath, id), mode)
 
     def upload_file_robustly(self, relpath, id, mode=None):
         """Upload a file, clearing the way on the remote side.

=== modified file 'breezy/plugins/weave_fmt/test_bzrdir.py'
--- breezy/plugins/weave_fmt/test_bzrdir.py	2017-11-12 13:53:51 +0000
+++ breezy/plugins/weave_fmt/test_bzrdir.py	2017-11-19 19:02:26 +0000
@@ -337,13 +337,13 @@
         foo_id = 'foo-20051004035605-91e788d1875603ae'
         rt.lock_read()
         try:
-            eq(rt.get_file_text(foo_id), 'initial contents\n')
+            eq(rt.get_file_text('foo', foo_id), 'initial contents\n')
         finally:
             rt.unlock()
         rt = b.repository.revision_tree(rh[1])
         rt.lock_read()
         try:
-            eq(rt.get_file_text(foo_id), 'new contents\n')
+            eq(rt.get_file_text('foo', foo_id), 'new contents\n')
         finally:
             rt.unlock()
         # check a backup was made:

=== modified file 'breezy/plugins/weave_fmt/test_repository.py'
--- breezy/plugins/weave_fmt/test_repository.py	2017-06-11 01:22:16 +0000
+++ breezy/plugins/weave_fmt/test_repository.py	2017-11-19 19:02:26 +0000
@@ -143,7 +143,7 @@
         control.create_branch()
         tree = control.create_workingtree()
         tree.add(['foo'], ['Foo:Bar'], ['file'])
-        tree.put_file_bytes_non_atomic('Foo:Bar', 'content\n')
+        tree.put_file_bytes_non_atomic('foo', 'content\n', 'Foo:Bar')
         try:
             tree.commit('first post', rev_id='first')
         except IllegalPath:

=== modified file 'breezy/rename_map.py'
--- breezy/rename_map.py	2017-11-11 18:16:54 +0000
+++ breezy/rename_map.py	2017-11-19 19:02:26 +0000
@@ -108,8 +108,7 @@
         try:
             for num, path in enumerate(paths):
                 task.update(gettext('Determining hash hits'), num, len(paths))
-                hits = self.hitcounts(self.tree.get_file_lines(None,
-                                                               path=path))
+                hits = self.hitcounts(self.tree.get_file_lines(path))
                 all_hits.extend((v, path, k) for k, v in viewitems(hits))
         finally:
             task.finished()

=== modified file 'breezy/revisionspec.py'
--- breezy/revisionspec.py	2017-11-12 13:53:51 +0000
+++ breezy/revisionspec.py	2017-11-19 19:02:26 +0000
@@ -897,12 +897,11 @@
             self._raise_invalid(numstring, context_branch)
         tree, file_path = workingtree.WorkingTree.open_containing(path)
         with tree.lock_read():
-            file_id = tree.path2id(file_path)
-            if file_id is None:
+            if not tree.has_filename(file_path):
                 raise errors.InvalidRevisionSpec(self.user_spec,
                     context_branch, "File '%s' is not versioned." %
                     file_path)
-            revision_ids = [r for (r, l) in tree.annotate_iter(file_id)]
+            revision_ids = [r for (r, l) in tree.annotate_iter(file_path)]
         try:
             revision_id = revision_ids[index]
         except IndexError:

=== modified file 'breezy/revisiontree.py'
--- breezy/revisiontree.py	2017-08-26 13:06:15 +0000
+++ breezy/revisiontree.py	2017-11-19 19:02:26 +0000
@@ -64,17 +64,19 @@
         """Return the revision id associated with this tree."""
         return self._revision_id
 
-    def get_file_revision(self, file_id, path=None):
+    def get_file_revision(self, path, file_id=None):
         """Return the revision id in which a file was last changed."""
         raise NotImplementedError(self.get_file_revision)
 
-    def get_file_text(self, file_id, path=None):
+    def get_file_text(self, path, file_id=None):
+        if file_id is None:
+            file_id = self.path2id(path)
         for (identifier, content) in self.iter_files_bytes([(file_id, None)]):
             ret = "".join(content)
         return ret
 
-    def get_file(self, file_id, path=None):
-        return BytesIO(self.get_file_text(file_id))
+    def get_file(self, path, file_id=None):
+        return BytesIO(self.get_file_text(path, file_id))
 
     def is_locked(self):
         return self._repository.is_locked()

=== modified file 'breezy/shelf.py'
--- breezy/shelf.py	2017-07-16 01:55:39 +0000
+++ breezy/shelf.py	2017-11-19 19:02:26 +0000
@@ -125,8 +125,10 @@
                 if kind[0] != kind [1]:
                     yield ('change kind', file_id, kind[0], kind[1], paths[0])
                 elif kind[0] == 'symlink':
-                    t_target = self.target_tree.get_symlink_target(file_id)
-                    w_target = self.work_tree.get_symlink_target(file_id)
+                    t_target = self.target_tree.get_symlink_target(
+                            paths[0], file_id)
+                    w_target = self.work_tree.get_symlink_target(
+                            paths[1], file_id)
                     yield ('modify target', file_id, paths[0], t_target,
                             w_target)
                 elif changed:
@@ -178,12 +180,14 @@
         :param new_target: The target that the symlink should have due
             to shelving.
         """
-        new_target = self.target_tree.get_symlink_target(file_id)
+        new_path = self.target_tree.id2path(file_id)
+        new_target = self.target_tree.get_symlink_target(new_path, file_id)
         w_trans_id = self.work_transform.trans_id_file_id(file_id)
         self.work_transform.delete_contents(w_trans_id)
         self.work_transform.create_symlink(new_target, w_trans_id)
 
-        old_target = self.work_tree.get_symlink_target(file_id)
+        old_path = self.work_tree.id2path(file_id)
+        old_target = self.work_tree.get_symlink_target(old_path, file_id)
         s_trans_id = self.shelf_transform.trans_id_file_id(file_id)
         self.shelf_transform.delete_contents(s_trans_id)
         self.shelf_transform.create_symlink(old_target, s_trans_id)
@@ -207,7 +211,8 @@
     def _content_from_tree(tt, tree, file_id):
         trans_id = tt.trans_id_file_id(file_id)
         tt.delete_contents(trans_id)
-        transform.create_from_tree(tt, trans_id, tree, file_id)
+        transform.create_from_tree(tt, trans_id, tree, tree.id2path(file_id),
+                                   file_id)
 
     def shelve_content_change(self, file_id):
         """Shelve a kind change or binary file content change.
@@ -263,15 +268,18 @@
                 if kind is None:
                     to_transform.create_file('', s_trans_id)
                 else:
-                    transform.create_from_tree(to_transform, s_trans_id,
-                                               tree, file_id)
+                    transform.create_from_tree(
+                            to_transform, s_trans_id, tree,
+                            tree.id2path(file_id), file_id)
         if version:
             to_transform.version_file(file_id, s_trans_id)
 
     def _inverse_lines(self, new_lines, file_id):
         """Produce a version with only those changes removed from new_lines."""
-        target_lines = self.target_tree.get_file_lines(file_id)
-        work_lines = self.work_tree.get_file_lines(file_id)
+        target_path = self.target_tree.id2path(file_id)
+        target_lines = self.target_tree.get_file_lines(target_path, file_id)
+        work_path = self.work_tree.id2path(file_id)
+        work_lines = self.work_tree.get_file_lines(work_path, file_id)
         return merge3.Merge3(new_lines, target_lines, work_lines).merge_lines()
 
     def finalize(self):

=== modified file 'breezy/shelf_ui.py'
--- breezy/shelf_ui.py	2017-07-16 01:55:39 +0000
+++ breezy/shelf_ui.py	2017-11-19 19:02:26 +0000
@@ -231,7 +231,6 @@
             self.change_editor.finish()
         self.work_tree.unlock()
 
-
     def get_parsed_patch(self, file_id, invert=False):
         """Return a parsed version of a file's patch.
 
@@ -300,7 +299,8 @@
         :param file_id: The id of the file that was modified.
         :return: The number of changes.
         """
-        work_tree_lines = self.work_tree.get_file_lines(file_id)
+        path = self.work_tree.id2path(file_id)
+        work_tree_lines = self.work_tree.get_file_lines(path, file_id)
         try:
             lines, change_count = self._select_hunks(creator, file_id,
                                                      work_tree_lines)
@@ -324,7 +324,8 @@
         if self.reporter.invert_diff:
             target_lines = work_tree_lines
         else:
-            target_lines = self.target_tree.get_file_lines(file_id)
+            path = self.target_tree.path2id(file_id)
+            target_lines = self.target_tree.get_file_lines(path, file_id)
         textfile.check_text_lines(work_tree_lines)
         textfile.check_text_lines(target_lines)
         parsed = self.get_parsed_patch(file_id, self.reporter.invert_diff)
@@ -362,7 +363,10 @@
             content of the file, and change_region_count is the number of
             changed regions.
         """
-        lines = osutils.split_lines(self.change_editor.edit_file(file_id))
+        lines = osutils.split_lines(self.change_editor.edit_file(
+            self.change_editor.old_tree.id2path(file_id),
+            self.change_editor.new_tree.id2path(file_id),
+            file_id=file_id))
         return lines, self._count_changed_regions(work_tree_lines, lines)
 
     @staticmethod

=== modified file 'breezy/tests/blackbox/test_merge.py'
--- breezy/tests/blackbox/test_merge.py	2017-11-16 00:39:04 +0000
+++ breezy/tests/blackbox/test_merge.py	2017-11-19 19:02:26 +0000
@@ -148,7 +148,7 @@
                              '=======\n'
                              'D\n'
                              '>>>>>>> MERGE-SOURCE\n',
-                             tree.get_file_text('f-id'))
+                             tree.get_file_text(tree.id2path('f-id')))
 
     def test_merge_explicit_reprocess_show_base(self):
         tree, other = self.create_conflicting_branches()
@@ -170,7 +170,7 @@
                              'B\n'
                              'D\n'
                              '>>>>>>> MERGE-SOURCE\n',
-                             tree.get_file_text('f-id'))
+                             tree.get_file_text(tree.id2path('f-id')))
 
     def test_merge_override_show_base(self):
         tree, other = self.create_conflicting_branches()
@@ -188,7 +188,7 @@
                              'B\n'
                              'D\n'
                              '>>>>>>> MERGE-SOURCE\n',
-                             tree.get_file_text('f-id'))
+                             tree.get_file_text(tree.id2path('f-id')))
 
     def test_merge_with_missing_file(self):
         """Merge handles missing file conflicts"""

=== modified file 'breezy/tests/blackbox/test_mkdir.py'
--- breezy/tests/blackbox/test_mkdir.py	2017-05-21 18:10:28 +0000
+++ breezy/tests/blackbox/test_mkdir.py	2017-11-19 19:02:26 +0000
@@ -27,33 +27,33 @@
     def test_mkdir(self):
         tree = self.make_branch_and_tree('.')
         self.run_bzr(['mkdir', 'somedir'])
-        self.assertEqual(tree.kind(tree.path2id('somedir')), "directory")
+        self.assertEqual(tree.kind('somedir'), "directory")
 
     def test_mkdir_multi(self):
         tree = self.make_branch_and_tree('.')
         self.run_bzr(['mkdir', 'somedir', 'anotherdir'])
-        self.assertEqual(tree.kind(tree.path2id('somedir')), "directory")
-        self.assertEqual(tree.kind(tree.path2id('anotherdir')), "directory")
+        self.assertEqual(tree.kind('somedir'), "directory")
+        self.assertEqual(tree.kind('anotherdir'), "directory")
 
     def test_mkdir_parents(self):
         tree = self.make_branch_and_tree('.')
         self.run_bzr(['mkdir', '-p', 'somedir/foo'])
-        self.assertEqual(tree.kind(tree.path2id('somedir/foo')), "directory")
+        self.assertEqual(tree.kind('somedir/foo'), "directory")
 
     def test_mkdir_parents_existing_versioned_dir(self):
         tree = self.make_branch_and_tree('.')
         tree.mkdir('somedir')
-        self.assertEqual(tree.kind(tree.path2id('somedir')), "directory")
+        self.assertEqual(tree.kind('somedir'), "directory")
         self.run_bzr(['mkdir', '-p', 'somedir'])
 
     def test_mkdir_parents_existing_unversioned_dir(self):
         tree = self.make_branch_and_tree('.')
         os.mkdir('somedir')
         self.run_bzr(['mkdir', '-p', 'somedir'])
-        self.assertEqual(tree.kind(tree.path2id('somedir')), "directory")
+        self.assertEqual(tree.kind('somedir'), "directory")
 
     def test_mkdir_parents_with_unversioned_parent(self):
         tree = self.make_branch_and_tree('.')
         os.mkdir('somedir')
         self.run_bzr(['mkdir', '-p', 'somedir/foo'])
-        self.assertEqual(tree.kind(tree.path2id('somedir/foo')), "directory")
+        self.assertEqual(tree.kind('somedir/foo'), "directory")

=== modified file 'breezy/tests/blackbox/test_resolve.py'
--- breezy/tests/blackbox/test_resolve.py	2017-06-13 10:58:47 +0000
+++ breezy/tests/blackbox/test_resolve.py	2017-11-19 19:02:26 +0000
@@ -119,7 +119,7 @@
         self.build_tree_contents([('tree/file',
             '<<<<<<<\na\n=======\n>>>>>>>\n')])
         tree.add('file', 'file_id')
-        self.assertEqual(tree.kind('file_id'), 'file')
+        self.assertEqual(tree.kind('file', 'file_id'), 'file')
         file_conflict = conflicts.TextConflict('file', file_id='file_id')
         tree.set_conflicts(conflicts.ConflictList([file_conflict]))
         note = self.run_bzr('resolve', retcode=1, working_dir='tree')[1]

=== modified file 'breezy/tests/blackbox/test_versioning.py'
--- breezy/tests/blackbox/test_versioning.py	2017-11-12 13:53:51 +0000
+++ breezy/tests/blackbox/test_versioning.py	2017-11-19 19:02:26 +0000
@@ -147,7 +147,7 @@
         new.lock_read()
 
         def get_text_by_path(tree, path):
-            return tree.get_file_text(tree.path2id(path), path)
+            return tree.get_file_text(path)
 
         self.assertEqual(get_text_by_path(new, 'b/two'), 'old contents')
         self.assertEqual(get_text_by_path(new, 'top'), 'old contents')

=== modified file 'breezy/tests/per_branch/test_branch.py'
--- breezy/tests/per_branch/test_branch.py	2017-10-07 22:42:22 +0000
+++ breezy/tests/per_branch/test_branch.py	2017-11-19 19:02:26 +0000
@@ -113,7 +113,7 @@
         tree = b2.repository.revision_tree(rev1)
         tree.lock_read()
         self.addCleanup(tree.unlock)
-        self.assertEqual(tree.get_file_text(tree.path2id('foo')), 'hello')
+        self.assertEqual(tree.get_file_text('foo'), 'hello')
 
     def get_unbalanced_tree_pair(self):
         """Return two branches, a and b, with one file in a."""

=== modified file 'breezy/tests/per_branch/test_commit.py'
--- breezy/tests/per_branch/test_commit.py	2017-10-07 22:42:22 +0000
+++ breezy/tests/per_branch/test_commit.py	2017-11-19 19:02:26 +0000
@@ -187,7 +187,7 @@
             # setting up a playground
             tree.add('rootfile')
             rootfile_id = tree.path2id('rootfile')
-            tree.put_file_bytes_non_atomic(rootfile_id, 'abc')
+            tree.put_file_bytes_non_atomic('rootfile', 'abc')
             tree.add('dir')
             dir_id = tree.path2id('dir')
             tree.add('dir/subfile')
@@ -202,9 +202,9 @@
         tree.lock_write()
         try:
             # making changes
-            tree.put_file_bytes_non_atomic(rootfile_id, 'jkl')
+            tree.put_file_bytes_non_atomic('rootfile', 'jkl')
             tree.rename_one('dir/subfile', 'dir/subfile_renamed')
-            tree.unversion([to_be_unversioned_id])
+            tree.unversion(['to_be_unversioned'])
             tree.mkdir('added_dir')
             added_dir_id = tree.path2id('added_dir')
             # start to capture pre_commit delta

=== modified file 'breezy/tests/per_branch/test_sprout.py'
--- breezy/tests/per_branch/test_sprout.py	2017-08-07 14:41:20 +0000
+++ breezy/tests/per_branch/test_sprout.py	2017-11-19 19:02:26 +0000
@@ -176,12 +176,9 @@
         tree.lock_read()
         self.addCleanup(tree.unlock)
         # Check that the symlink target is safely round-tripped in the trees.
-        self.assertEqual(
-            target,
-            tree.get_symlink_target(tree.path2id(link_name)))
-        self.assertEqual(
-            target,
-            tree.basis_tree().get_symlink_target(tree.path2id(link_name)))
+        self.assertEqual(target, tree.get_symlink_target(link_name))
+        self.assertEqual(target,
+                tree.basis_tree().get_symlink_target(link_name))
 
     def test_sprout_with_ghost_in_mainline(self):
         tree = self.make_branch_and_tree('tree1')

=== modified file 'breezy/tests/per_branch/test_stacking.py'
--- breezy/tests/per_branch/test_stacking.py	2017-08-07 21:10:20 +0000
+++ breezy/tests/per_branch/test_stacking.py	2017-11-19 19:02:26 +0000
@@ -483,9 +483,7 @@
         rtree = target.repository.revision_tree(rev2)
         rtree.lock_read()
         self.addCleanup(rtree.unlock)
-        self.assertEqual(
-            'new content',
-            rtree.get_file_text(rtree.path2id('a'), 'a'))
+        self.assertEqual('new content', rtree.get_file_text('a'))
         self.check_lines_added_or_present(target, rev2)
 
     def test_transform_fallback_location_hook(self):

=== modified file 'breezy/tests/per_foreign_vcs/test_branch.py'
--- breezy/tests/per_foreign_vcs/test_branch.py	2017-07-23 17:17:18 +0000
+++ breezy/tests/per_foreign_vcs/test_branch.py	2017-11-19 19:02:26 +0000
@@ -29,6 +29,9 @@
 from breezy.tests import (
     TestCaseWithTransport,
     )
+from breezy.sixish import (
+    text_type,
+    )
 
 
 class ForeignBranchFactory(object):
@@ -96,8 +99,8 @@
     def test__get_nick(self):
         """Make sure _get_nick is implemented and returns a string."""
         branch = self.make_branch()
-        self.assertIsInstance(branch._get_nick(local=False), str)
-        self.assertIsInstance(branch._get_nick(local=True), str)
+        self.assertIsInstance(branch._get_nick(local=False), text_type)
+        self.assertIsInstance(branch._get_nick(local=True), text_type)
 
     def test_null_revid_revno(self):
         """null: should return revno 0."""

=== modified file 'breezy/tests/per_interbranch/test_fetch.py'
--- breezy/tests/per_interbranch/test_fetch.py	2017-08-10 00:51:26 +0000
+++ breezy/tests/per_interbranch/test_fetch.py	2017-11-19 19:02:26 +0000
@@ -42,9 +42,7 @@
         tree = b2.repository.revision_tree(rev1)
         tree.lock_read()
         self.addCleanup(tree.unlock)
-        self.assertEqual(
-                tree.get_file_text(tree.path2id('foo'), 'foo'),
-                'hello')
+        self.assertEqual(tree.get_file_text('foo'), 'hello')
 
     def test_fetch_revisions_limit(self):
         """Test fetch-revision operation."""

=== modified file 'breezy/tests/per_interrepository/test_fetch.py'
--- breezy/tests/per_interrepository/test_fetch.py	2017-11-16 00:39:04 +0000
+++ breezy/tests/per_interrepository/test_fetch.py	2017-11-19 19:02:26 +0000
@@ -77,10 +77,10 @@
             tree = repo.revision_tree('rev1')
             tree.lock_read()
             self.addCleanup(tree.unlock)
-            tree.get_file_text('file1')
+            tree.get_file_text('foo')
             for file_id in tree.all_file_ids():
-                if tree.kind(file_id) == "file":
-                    tree.get_file(file_id).read()
+                if tree.kind(tree.id2path(file_id)) == "file":
+                    tree.get_file(tree.id2path(file_id)).read()
 
         # makes a target version repo
         repo_b = self.make_to_repository('b')
@@ -421,7 +421,7 @@
         """If fetching a delta, we should die if a basis is not present."""
         tree = self.make_branch_and_tree('tree')
         self.build_tree(['tree/a'])
-        tree.add(['a'], ['a-id'])
+        tree.add(['a'])
         tree.commit('one', rev_id='rev-one')
         self.build_tree_contents([('tree/a', 'new contents\n')])
         tree.commit('two', rev_id='rev-two')
@@ -465,7 +465,7 @@
             try:
                 rt = to_repo.revision_tree('rev-two')
                 self.assertEqual('new contents\n',
-                                 rt.get_file_text('a-id'))
+                                 rt.get_file_text('a'))
             finally:
                 to_repo.unlock()
 

=== modified file 'breezy/tests/per_intertree/test_compare.py'
--- breezy/tests/per_intertree/test_compare.py	2017-10-08 02:49:53 +0000
+++ breezy/tests/per_intertree/test_compare.py	2017-11-19 19:02:26 +0000
@@ -789,13 +789,15 @@
         tree1.mkdir('changing', 'parent-id')
         tree1.mkdir('changing/unchanging', 'mid-id')
         tree1.add(['changing/unchanging/file'], ['file-id'], ['file'])
-        tree1.put_file_bytes_non_atomic('file-id', 'a file')
+        tree1.put_file_bytes_non_atomic(
+                'changing/unchanging/file', 'a file', file_id='file-id')
         tree2 = self.make_to_branch_and_tree('2')
         tree2.set_root_id(tree1.get_root_id())
         tree2.mkdir('changed', 'parent-id')
         tree2.mkdir('changed/unchanging', 'mid-id')
         tree2.add(['changed/unchanging/file'], ['file-id'], ['file'])
-        tree2.put_file_bytes_non_atomic('file-id', 'changed content')
+        tree2.put_file_bytes_non_atomic(
+                'changed/unchanging/file', 'changed content', file_id='file-id')
         tree1, tree2 = self.mutable_trees_to_test_trees(self, tree1, tree2)
         # parent-id has changed, as has file-id
         root_id = tree1.path2id('')
@@ -814,13 +816,16 @@
         tree1.mkdir('changed', 'parent-id')
         tree1.mkdir('changed/unchanging', 'mid-id')
         tree1.add(['changed/unchanging/file'], ['file-id'], ['file'])
-        tree1.put_file_bytes_non_atomic('file-id', 'a file')
+        tree1.put_file_bytes_non_atomic(
+                'changed/unchanging/file', 'a file',
+                'file-id')
         tree2 = self.make_to_branch_and_tree('2')
         tree2.set_root_id('new')
         tree2.mkdir('changed', 'parent-id')
         tree2.mkdir('changed/unchanging', 'mid-id')
         tree2.add(['changed/unchanging/file'], ['file-id'], ['file'])
-        tree2.put_file_bytes_non_atomic('file-id', 'changed content')
+        tree2.put_file_bytes_non_atomic(
+                'changed/unchanging/file', 'changed content', file_id='file-id')
         tree1, tree2 = self.mutable_trees_to_locked_test_trees(tree1, tree2)
         # old is gone, new is added, parent-id has changed(reparented), as has
         # file-id(content)
@@ -866,12 +871,12 @@
         # it must be emitted as a change.
         tree1 = self.make_branch_and_tree('1')
         tree1.add(['a'], ['a-id'], ['file'])
-        tree1.put_file_bytes_non_atomic('a-id', 'a file')
+        tree1.put_file_bytes_non_atomic('a', 'a file')
         tree2 = self.make_to_branch_and_tree('2')
         tree2.set_root_id(tree1.get_root_id())
         tree2.mkdir('a', 'b-id')
         tree2.add(['a/c'], ['c-id'], ['file'])
-        tree2.put_file_bytes_non_atomic('c-id', 'another file')
+        tree2.put_file_bytes_non_atomic('a/c', 'another file')
         tree1, tree2 = self.mutable_trees_to_locked_test_trees(tree1, tree2)
         # a-id is gone, b-id and c-id are added.
         self.assertEqualIterChanges(
@@ -892,7 +897,7 @@
         tree2.mkdir('a', 'a-new-id')
         tree2.mkdir('a/reparented', 'reparented-id')
         tree2.add(['b'], ['a-old-id'], ['file'])
-        tree2.put_file_bytes_non_atomic('a-old-id', '')
+        tree2.put_file_bytes_non_atomic('b', '')
         tree1, tree2 = self.mutable_trees_to_locked_test_trees(tree1, tree2)
         # a-old-id is kind-changed, a-new-id is added, reparented-id is renamed,
         # deleted-id is gone

=== modified file 'breezy/tests/per_merger.py'
--- breezy/tests/per_merger.py	2017-11-16 00:39:04 +0000
+++ breezy/tests/per_merger.py	2017-11-19 19:02:26 +0000
@@ -312,7 +312,7 @@
         conflicts = builder.merge(self.merge_type)
         self.assertEqual(conflicts, [])
         self.assertEqual(
-            builder.this.get_file('1').read(), 'text-merged-by-hook')
+            builder.this.get_file('name1').read(), 'text-merged-by-hook')
 
     def test_change_vs_deleted(self):
         """Hook is used for (changed, deleted)"""
@@ -324,7 +324,7 @@
         conflicts = builder.merge(self.merge_type)
         self.assertEqual(conflicts, [])
         self.assertEqual(
-            builder.this.get_file('1').read(), 'text-merged-by-hook')
+            builder.this.get_file('name1').read(), 'text-merged-by-hook')
 
     def test_result_can_be_delete(self):
         """A hook's result can be the deletion of a file."""
@@ -346,7 +346,7 @@
         # The hook still gets to set the file contents in this case, so that it
         # can insert custom conflict markers.
         self.assertEqual(
-            builder.this.get_file('1').read(),
+            builder.this.get_file('name1').read(),
             'text-with-conflict-markers-from-hook')
 
     def test_can_access_this_other_and_base_versions(self):
@@ -370,7 +370,7 @@
         conflicts = builder.merge(self.merge_type)
         self.assertEqual(conflicts, [])
         self.assertEqual(
-            builder.this.get_file('1').read(), 'text-merged-by-hook')
+            builder.this.get_file('name1').read(), 'text-merged-by-hook')
         self.assertEqual([('inactive',), ('success',)], self.hook_log)
 
     def test_chain_when_not_applicable(self):
@@ -384,7 +384,7 @@
         conflicts = builder.merge(self.merge_type)
         self.assertEqual(conflicts, [])
         self.assertEqual(
-            builder.this.get_file('1').read(), 'text-merged-by-hook')
+            builder.this.get_file('name1').read(), 'text-merged-by-hook')
         self.assertEqual([('no-op',), ('success',)], self.hook_log)
 
     def test_chain_stops_after_success(self):

=== modified file 'breezy/tests/per_repository/test_commit_builder.py'
--- breezy/tests/per_repository/test_commit_builder.py	2017-08-28 00:44:07 +0000
+++ breezy/tests/per_repository/test_commit_builder.py	2017-11-19 19:02:26 +0000
@@ -193,7 +193,7 @@
             builder.commit('')
             builder_tree = builder.revision_tree()
             new_root_id = builder_tree.get_root_id()
-            new_root_revision = builder_tree.get_file_revision(new_root_id)
+            new_root_revision = builder_tree.get_file_revision(u'')
             if tree.branch.repository.supports_rich_root():
                 # We should not have seen a new root revision
                 self.assertEqual(old_revision_id, new_root_revision)
@@ -267,7 +267,7 @@
         basis_tree.lock_read()
         self.addCleanup(basis_tree.unlock)
         self.assertEqual(rev_id,
-            basis_tree.get_file_revision(basis_tree.get_root_id()))
+            basis_tree.get_file_revision(u'', basis_tree.get_root_id()))
 
     def _get_revtrees(self, tree, revision_ids):
         tree.lock_read()
@@ -287,13 +287,11 @@
         rev1 = tree.commit('')
         rev2 = tree.commit('')
         tree1, tree2 = self._get_revtrees(tree, [rev1, rev2])
-        self.assertEqual(rev1, tree1.get_file_revision(tree1.get_root_id()))
+        self.assertEqual(rev1, tree1.get_file_revision(u''))
         if tree.branch.repository.supports_rich_root():
-            self.assertEqual(rev1,
-                tree2.get_file_revision(tree2.get_root_id()))
+            self.assertEqual(rev1,tree2.get_file_revision(u''))
         else:
-            self.assertEqual(rev2,
-                tree2.get_file_revision(tree2.get_root_id()))
+            self.assertEqual(rev2, tree2.get_file_revision(u''))
 
     def _add_commit_check_unchanged(self, tree, name, mini_commit=None):
         tree.add([name])
@@ -304,8 +302,8 @@
         rev1 = tree.commit('')
         rev2 = mini_commit(tree, name, name, False, False)
         tree1, tree2 = self._get_revtrees(tree, [rev1, rev2])
-        self.assertEqual(rev1, tree1.get_file_revision(file_id))
-        self.assertEqual(rev1, tree2.get_file_revision(file_id))
+        self.assertEqual(rev1, tree1.get_file_revision(tree1.id2path(file_id)))
+        self.assertEqual(rev1, tree2.get_file_revision(tree2.id2path(file_id)))
         expected_graph = {}
         expected_graph[(file_id, rev1)] = ()
         self.assertFileGraph(expected_graph, tree, (file_id, rev1))
@@ -329,8 +327,8 @@
         tree.add(['dir/content'])
         rev2 = tree.commit('')
         tree1, tree2 = self._get_revtrees(tree, [rev1, rev2])
-        self.assertEqual(rev1, tree1.get_file_revision(dir_id))
-        self.assertEqual(rev1, tree2.get_file_revision(dir_id))
+        self.assertEqual(rev1, tree1.get_file_revision('dir'))
+        self.assertEqual(rev1, tree2.get_file_revision('dir'))
         expected_graph = {}
         expected_graph[(dir_id, rev1)] = ()
         self.assertFileGraph(expected_graph, tree, (dir_id, rev1))
@@ -459,8 +457,8 @@
         rev2 = mini_commit(tree, name, tree.id2path(file_id),
             expect_fs_hash=expect_fs_hash)
         tree1, tree2 = self._get_revtrees(tree, [rev1, rev2])
-        self.assertEqual(rev1, tree1.get_file_revision(file_id))
-        self.assertEqual(rev2, tree2.get_file_revision(file_id))
+        self.assertEqual(rev1, tree1.get_file_revision(tree1.id2path(file_id)))
+        self.assertEqual(rev2, tree2.get_file_revision(tree2.id2path(file_id)))
         expected_graph = {}
         expected_graph[(file_id, rev1)] = ()
         expected_graph[(file_id, rev2)] = ((file_id, rev1),)
@@ -500,12 +498,12 @@
                 changes))
             file_id = tree.path2id(new_name)
             if expect_fs_hash:
-                tree_file_stat = tree.get_file_with_stat(file_id)
+                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(file_id))
+                self.assertEqual(result[2][0], tree.get_file_sha1(new_name))
                 self.assertEqualStat(result[2][1], tree_file_stat[1])
             else:
                 self.assertEqual([], result)
@@ -556,7 +554,7 @@
         tree = self.make_branch_and_tree('.')
         self.build_tree(['file'])
         def change_file():
-            tree.put_file_bytes_non_atomic(tree.path2id('file'), 'new content')
+            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)
@@ -604,7 +602,7 @@
         rev4 = mini_commit(tree1, 'new_' + name, 'new_' + name,
             expect_fs_hash=expect_fs_hash)
         tree3, = self._get_revtrees(tree1, [rev4])
-        self.assertEqual(rev4, tree3.get_file_revision(file_id))
+        self.assertEqual(rev4, tree3.get_file_revision(tree3.id2path(file_id)))
         expected_graph = {}
         expected_graph[(file_id, rev1)] = ()
         expected_graph[(file_id, rev2)] = ((file_id, rev1),)
@@ -649,7 +647,9 @@
             rev3 = mini_commit(in_tree, name, 'new_' + name, False,
                 delta_against_basis=changed_in_tree)
             tree3, = self._get_revtrees(in_tree, [rev2])
-            self.assertEqual(rev2, tree3.get_file_revision(file_id))
+            self.assertEqual(
+                    rev2,
+                    tree3.get_file_revision(tree3.id2path(file_id), file_id))
             expected_graph = {}
             expected_graph[(file_id, rev1)] = ()
             expected_graph[(file_id, rev2)] = ((file_id, rev1),)
@@ -678,7 +678,7 @@
         rev3 = mini_commit(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(file_id))
+        self.assertEqual(rev2, tree3.get_file_revision(tree3.id2path(file_id)))
         expected_graph = {}
         expected_graph[(file_id, rev2)] = ()
         self.assertFileGraph(expected_graph, tree1, (file_id, rev2))

=== modified file 'breezy/tests/per_repository/test_fetch.py'
--- breezy/tests/per_repository/test_fetch.py	2017-11-16 00:39:04 +0000
+++ breezy/tests/per_repository/test_fetch.py	2017-11-19 19:02:26 +0000
@@ -87,7 +87,7 @@
         rev1_tree = knit3_repo.revision_tree(rev1)
         rev1_tree.lock_read()
         try:
-            lines = rev1_tree.get_file_lines(rev1_tree.get_root_id())
+            lines = rev1_tree.get_file_lines(u'', rev1_tree.get_root_id())
         finally:
             rev1_tree.unlock()
         self.assertEqual([], lines)
@@ -105,7 +105,7 @@
         rev2_tree = knit3_repo.revision_tree(rev2)
         self.assertEqual(
             rev1,
-            rev2_tree.get_file_revision(rev2_tree.get_root_id()))
+            rev2_tree.get_file_revision(u'', rev2_tree.get_root_id()))
 
     def do_test_fetch_to_rich_root_sets_parents_correctly(self, result,
         snapshots, root_id=ROOT_ID, allow_lefthand_ghost=False):

=== modified file 'breezy/tests/per_repository/test_repository.py'
--- breezy/tests/per_repository/test_repository.py	2017-11-16 00:39:04 +0000
+++ breezy/tests/per_repository/test_repository.py	2017-11-19 19:02:26 +0000
@@ -140,7 +140,7 @@
         tree_b = repo_b.revision_tree(rev1)
         tree_b.lock_read()
         self.addCleanup(tree_b.unlock)
-        tree_b.get_file_text(file_id)
+        tree_b.get_file_text('foo')
         repo_b.get_revision(rev1)
 
     def test_supports_rich_root(self):
@@ -150,7 +150,7 @@
         rev_tree = tree.branch.repository.revision_tree(second_revision)
         rev_tree.lock_read()
         self.addCleanup(rev_tree.unlock)
-        root_revision = rev_tree.get_file_revision(rev_tree.get_root_id())
+        root_revision = rev_tree.get_file_revision(u'', rev_tree.get_root_id())
         rich_root = (root_revision != second_revision)
         self.assertEqual(rich_root,
                          tree.branch.repository.supports_rich_root())
@@ -261,7 +261,7 @@
         tree.lock_read()
         try:
             self.assertEqual(rev1,
-                tree.get_file_revision(tree.get_root_id()))
+                tree.get_file_revision(u'', tree.get_root_id()))
             expected = inventory.InventoryDirectory('fixed-root', '', None)
             expected.revision = rev1
             self.assertEqual([('', 'V', 'directory', 'fixed-root', expected)],
@@ -452,7 +452,7 @@
         rev_tree.lock_read()
         self.addCleanup(rev_tree.unlock)
         root_id = rev_tree.get_root_id()
-        self.assertEqual(revid, rev_tree.get_file_revision(root_id))
+        self.assertEqual(revid, rev_tree.get_file_revision(u'', root_id))
 
     def test_pointless_commit(self):
         tree = self.make_branch_and_tree('.')
@@ -568,24 +568,23 @@
     def test_add_signature_text(self):
         builder = self.make_branch_builder('.')
         builder.start_series()
-        builder.build_snapshot(None, [
-            ('add', ('', 'root-id', 'directory', None))],
-            revision_id='A')
+        rev_a = builder.build_snapshot(None, [
+            ('add', ('', 'root-id', 'directory', None))])
         builder.finish_series()
         b = builder.get_branch()
         b.lock_write()
         self.addCleanup(b.unlock)
         if b.repository._format.supports_revision_signatures:
             b.repository.start_write_group()
-            b.repository.add_signature_text('A', 'This might be a signature')
+            b.repository.add_signature_text(rev_a, 'This might be a signature')
             b.repository.commit_write_group()
             self.assertEqual('This might be a signature',
-                             b.repository.get_signature_text('A'))
+                             b.repository.get_signature_text(rev_a))
         else:
             b.repository.start_write_group()
             self.addCleanup(b.repository.abort_write_group)
             self.assertRaises(errors.UnsupportedOperation,
-                b.repository.add_signature_text, 'A',
+                b.repository.add_signature_text, rev_a,
                 'This might be a signature')
 
     # XXX: this helper duplicated from tests.test_repository
@@ -934,7 +933,7 @@
         revtree = branch.repository.revision_tree(rev1)
         revtree.lock_read()
         self.addCleanup(revtree.unlock)
-        contents = revtree.get_file_text(FOO_ID)
+        contents = revtree.get_file_text(u'', FOO_ID)
         self.assertEqual(contents, 'contents of repo/foo\n')
 
     def test_create_bundle(self):

=== modified file 'breezy/tests/per_repository/test_revision.py'
--- breezy/tests/per_repository/test_revision.py	2017-08-07 19:09:47 +0000
+++ breezy/tests/per_repository/test_revision.py	2017-11-19 19:02:26 +0000
@@ -84,7 +84,9 @@
                      timestamp=rev_a.timestamp,
                      timezone=rev_a.timezone,
                      committer=rev_a.committer,
-                     rev_id=rev_a.revision_id,
+                     rev_id=(rev_a.revision_id
+                         if tree2.branch.repository._format.supports_setting_revision_ids
+                         else None),
                      revprops=rev_a.properties,
                      allow_pointless=True, # there's nothing in this commit
                      strict=True,

=== modified file 'breezy/tests/per_repository_vf/test_merge_directive.py'
--- breezy/tests/per_repository_vf/test_merge_directive.py	2017-11-16 00:39:04 +0000
+++ breezy/tests/per_repository_vf/test_merge_directive.py	2017-11-19 19:02:26 +0000
@@ -77,5 +77,5 @@
         directive.install_revisions(target_branch.repository)
         rt = target_branch.repository.revision_tree('B')
         rt.lock_read()
-        self.assertEqualDiff('new content\n', rt.get_file_text('f-id'))
+        self.assertEqualDiff('new content\n', rt.get_file_text('f', 'f-id'))
         rt.unlock()

=== modified file 'breezy/tests/per_repository_vf/test_repository.py'
--- breezy/tests/per_repository_vf/test_repository.py	2017-06-10 16:40:42 +0000
+++ breezy/tests/per_repository_vf/test_repository.py	2017-11-19 19:02:26 +0000
@@ -271,7 +271,7 @@
         try:
             self.assertEqual(set(), set(repo.texts.keys()))
             tree.add(['foo'], [file_id], ['file'])
-            tree.put_file_bytes_non_atomic(file_id, 'content\n')
+            tree.put_file_bytes_non_atomic('foo', 'content\n', file_id=file_id)
             try:
                 rev_key = (tree.commit("foo"),)
             except errors.IllegalPath:
@@ -294,16 +294,16 @@
             tree.unlock()
         tree2 = self.make_branch_and_tree('tree2')
         tree2.pull(tree.branch)
-        tree2.put_file_bytes_non_atomic('Foo:Bar', 'right\n')
+        tree2.put_file_bytes_non_atomic('foo', 'right\n', file_id='Foo:Bar')
         right_key = (tree2.commit('right'),)
         keys.add(file_key + right_key)
         parents[file_key + right_key] = (file_key + rev_key,)
-        tree.put_file_bytes_non_atomic('Foo:Bar', 'left\n')
+        tree.put_file_bytes_non_atomic('foo', 'left\n', file_id='Foo:Bar')
         left_key = (tree.commit('left'),)
         keys.add(file_key + left_key)
         parents[file_key + left_key] = (file_key + rev_key,)
         tree.merge_from_branch(tree2.branch)
-        tree.put_file_bytes_non_atomic('Foo:Bar', 'merged\n')
+        tree.put_file_bytes_non_atomic('foo', 'merged\n', file_id='Foo:Bar')
         try:
             tree.auto_resolve()
         except errors.UnsupportedOperation:

=== modified file 'breezy/tests/per_repository_vf/test_write_group.py'
--- breezy/tests/per_repository_vf/test_write_group.py	2017-11-16 00:39:04 +0000
+++ breezy/tests/per_repository_vf/test_write_group.py	2017-11-19 19:02:26 +0000
@@ -70,7 +70,9 @@
         tree.add([''], ['TREE_ROOT'], ['directory'])
         tree.add(['dir'], ['dir-id'], ['directory'])
         tree.add(['filename'], ['file-id'], ['file'])
-        tree.put_file_bytes_non_atomic('file-id', 'content\n')
+        tree.put_file_bytes_non_atomic(
+                'filename', 'content\n',
+                file_id='file-id')
         tree.commit('Trunk commit', rev_id='rev-0')
         tree.commit('Trunk commit', rev_id='rev-1')
         tree.unlock()

=== modified file 'breezy/tests/per_tree/test_annotate_iter.py'
--- breezy/tests/per_tree/test_annotate_iter.py	2017-08-07 21:14:18 +0000
+++ breezy/tests/per_tree/test_annotate_iter.py	2017-11-19 19:02:26 +0000
@@ -45,11 +45,11 @@
         tree.lock_read()
         self.addCleanup(tree.unlock)
         self.assertEqual([(revids[1], 'second\n'), (revids[0], 'content\n')],
-                         list(tree.annotate_iter(tree.path2id('one'))))
+                         list(tree.annotate_iter('one')))
 
     def test_annotate_with_ghost(self):
         tree, revids = self.get_tree_with_ghost()
         tree.lock_read()
         self.addCleanup(tree.unlock)
         self.assertEqual([(revids[1], 'second\n'), (revids[0], 'content\n')],
-                         list(tree.annotate_iter(tree.path2id('one'))))
+                         list(tree.annotate_iter('one')))

=== modified file 'breezy/tests/per_tree/test_get_file_mtime.py'
--- breezy/tests/per_tree/test_get_file_mtime.py	2017-08-01 01:44:41 +0000
+++ breezy/tests/per_tree/test_get_file_mtime.py	2017-11-19 19:02:26 +0000
@@ -38,17 +38,15 @@
         self.addCleanup(tree.unlock)
         # Committed trees return the time of the commit that last changed the
         # file, working trees return the on-disk time.
-        mtime_file_id = tree.get_file_mtime(file_id=tree.path2id('one'))
+        mtime_file_id = tree.get_file_mtime('one')
         self.assertIsInstance(mtime_file_id, (float, int))
         self.assertTrue(now - 5 < mtime_file_id < now + 5,
                         'now: %f, mtime_file_id: %f' % (now, mtime_file_id ))
-        mtime_path = tree.get_file_mtime(
-                file_id=tree.path2id('one'), path='one')
+        mtime_path = tree.get_file_mtime('one')
         self.assertEqual(mtime_file_id, mtime_path)
 
     def test_nonexistant(self):
         tree = self.get_basic_tree()
         tree.lock_read()
         self.addCleanup(tree.unlock)
-        self.assertRaises(errors.NoSuchId,
-            tree.get_file_mtime, file_id='unexistant')
+        self.assertRaises(errors.NoSuchFile, tree.get_file_mtime, 'unexistant')

=== modified file 'breezy/tests/per_tree/test_get_file_with_stat.py'
--- breezy/tests/per_tree/test_get_file_with_stat.py	2017-08-01 01:44:41 +0000
+++ breezy/tests/per_tree/test_get_file_with_stat.py	2017-11-19 19:02:26 +0000
@@ -31,8 +31,7 @@
         tree = self._convert_tree(work_tree)
         tree.lock_read()
         self.addCleanup(tree.unlock)
-        file_obj, statvalue = tree.get_file_with_stat(
-            tree.path2id('foo'))
+        file_obj, statvalue = tree.get_file_with_stat('foo')
         self.addCleanup(file_obj.close)
         if statvalue is not None:
             expected = os.lstat('foo')
@@ -46,8 +45,7 @@
         tree = self._convert_tree(work_tree)
         tree.lock_read()
         self.addCleanup(tree.unlock)
-        file_obj, statvalue = tree.get_file_with_stat(
-            tree.path2id('foo'), 'foo')
+        file_obj, statvalue = tree.get_file_with_stat('foo')
         self.addCleanup(file_obj.close)
         if statvalue is not None:
             expected = os.lstat('foo')

=== modified file 'breezy/tests/per_tree/test_get_symlink_target.py'
--- breezy/tests/per_tree/test_get_symlink_target.py	2017-08-01 01:44:41 +0000
+++ breezy/tests/per_tree/test_get_symlink_target.py	2017-11-19 19:02:26 +0000
@@ -44,13 +44,13 @@
         tree = self.get_tree_with_symlinks()
         tree.lock_read()
         self.addCleanup(tree.unlock)
-        self.assertEqual('foo', tree.get_symlink_target(tree.path2id('link')))
+        self.assertEqual('foo', tree.get_symlink_target('link'))
         self.assertEqual('../bar',
-                         tree.get_symlink_target(tree.path2id('rel_link')))
+                         tree.get_symlink_target('rel_link'))
         self.assertEqual('/baz/bing',
-                         tree.get_symlink_target(tree.path2id('abs_link')))
+                         tree.get_symlink_target('abs_link'))
         self.assertEqual('foo',
-                         tree.get_symlink_target(tree.path2id('link'), 'link'))
+                         tree.get_symlink_target('link', tree.path2id('link')))
 
     def test_get_unicode_symlink_target(self):
         self.requireFeature(features.SymlinkFeature)
@@ -62,6 +62,6 @@
         file_id = tree.path2id(u'\u03b2_link')
         tree.lock_read()
         self.addCleanup(tree.unlock)
-        actual = tree.get_symlink_target(file_id)
+        actual = tree.get_symlink_target(u'\u03b2_link')
         self.assertEqual(target, actual)
 

=== modified file 'breezy/tests/per_tree/test_is_executable.py'
--- breezy/tests/per_tree/test_is_executable.py	2017-08-01 01:44:41 +0000
+++ breezy/tests/per_tree/test_is_executable.py	2017-11-19 19:02:26 +0000
@@ -29,7 +29,7 @@
             False)
         tree.lock_read()
         self.addCleanup(tree.unlock)
-        self.assertEqual(False, tree.is_executable(tree.path2id('1top-dir')))
+        self.assertEqual(False, tree.is_executable('1top-dir'))
 
     def test_is_executable_symlink(self):
         self.requireFeature(SymlinkFeature)

=== modified file 'breezy/tests/per_tree/test_test_trees.py'
--- breezy/tests/per_tree/test_test_trees.py	2017-10-08 02:49:53 +0000
+++ breezy/tests/per_tree/test_test_trees.py	2017-11-19 19:02:26 +0000
@@ -52,8 +52,8 @@
         self.assertEqual(
             [(p, tree.path2id(p)) for p in ['', 'a', 'b', 'b/c']],
             [(path, node.file_id) for path, node in tree.iter_entries_by_dir()])
-        self.assertEqualDiff('contents of a\n', tree.get_file_text(tree.path2id('a')))
-        self.assertFalse(tree.is_executable(tree.path2id('b/c'), path='b/c'))
+        self.assertEqualDiff('contents of a\n', tree.get_file_text('a'))
+        self.assertFalse(tree.is_executable('b/c'))
 
     def test_abc_tree_content_2_no_parents(self):
         tree = self.make_branch_and_tree('.')
@@ -70,8 +70,8 @@
         self.assertEqual(
             [(p, tree.path2id(p)) for p in ['', 'a', 'b', 'b/c']],
             [(path, node.file_id) for path, node in tree.iter_entries_by_dir()])
-        self.assertEqualDiff('foobar\n', tree.get_file_text(tree.path2id('a')))
-        self.assertFalse(tree.is_executable(tree.path2id('b//c')))
+        self.assertEqualDiff('foobar\n', tree.get_file_text('a'))
+        self.assertFalse(tree.is_executable('b//c'))
 
     def test_abc_tree_content_3_no_parents(self):
         tree = self.make_branch_and_tree('.')
@@ -88,8 +88,8 @@
         self.assertEqual(
             [(p, tree.path2id(p)) for p in ['', 'a', 'b', 'b/c']],
             [(path, node.file_id) for path, node in tree.iter_entries_by_dir()])
-        self.assertEqualDiff('contents of a\n', tree.get_file_text(tree.path2id('a')))
-        self.assertTrue(tree.is_executable(tree.path2id('b/c')))
+        self.assertEqualDiff('contents of a\n', tree.get_file_text('a'))
+        self.assertTrue(tree.is_executable('b/c'))
 
     def test_abc_tree_content_4_no_parents(self):
         tree = self.make_branch_and_tree('.')
@@ -106,8 +106,8 @@
         self.assertEqual(
             [(p, tree.path2id(p)) for p in ['', 'b', 'd', 'b/c']],
             [(path, node.file_id) for path, node in tree.iter_entries_by_dir()])
-        self.assertEqualDiff('contents of a\n', tree.get_file_text(tree.path2id('d')))
-        self.assertFalse(tree.is_executable(tree.path2id('b/c')))
+        self.assertEqualDiff('contents of a\n', tree.get_file_text('d'))
+        self.assertFalse(tree.is_executable('b/c'))
 
     def test_abc_tree_content_5_no_parents(self):
         tree = self.make_branch_and_tree('.')
@@ -124,8 +124,8 @@
         self.assertEqual(
             [(p, tree.path2id(p)) for p in ['', 'b', 'd',  'b/c']],
             [(path, node.file_id) for path, node in tree.iter_entries_by_dir()])
-        self.assertEqualDiff('bar\n', tree.get_file_text(tree.path2id('d')))
-        self.assertFalse(tree.is_executable(tree.path2id('b/c')))
+        self.assertEqualDiff('bar\n', tree.get_file_text('d'))
+        self.assertFalse(tree.is_executable('b/c'))
 
     def test_abc_tree_content_6_no_parents(self):
         tree = self.make_branch_and_tree('.')
@@ -142,8 +142,8 @@
         self.assertEqual(
             [(p, tree.path2id(p)) for p in ['', 'a', 'b',  'e']],
             [(path, node.file_id) for path, node in tree.iter_entries_by_dir()])
-        self.assertEqualDiff('contents of a\n', tree.get_file_text(tree.path2id('a')))
-        self.assertTrue(tree.is_executable(tree.path2id('e')))
+        self.assertEqualDiff('contents of a\n', tree.get_file_text('a'))
+        self.assertTrue(tree.is_executable('e'))
 
     def test_tree_with_subdirs_and_all_content_types(self):
         # currently this test tree requires unicode. It might be good

=== modified file 'breezy/tests/per_tree/test_tree.py'
--- breezy/tests/per_tree/test_tree.py	2017-10-08 02:49:53 +0000
+++ breezy/tests/per_tree/test_tree.py	2017-11-19 19:02:26 +0000
@@ -36,12 +36,11 @@
         tree_revision = getattr(tree, 'get_revision_id', lambda: 'current:')()
         tree.lock_read()
         self.addCleanup(tree.unlock)
-        a_id = tree.path2id('a')
-        for revision, line in tree.annotate_iter(a_id):
+        for revision, line in tree.annotate_iter('a'):
             self.assertEqual('contents of a\n', line)
             self.assertEqual(tree_revision, revision)
         tree_revision = getattr(tree, 'get_revision_id', lambda: 'random:')()
-        for revision, line in tree.annotate_iter(a_id, 'random:'):
+        for revision, line in tree.annotate_iter('a', default_revision='random:'):
             self.assertEqual('contents of a\n', line)
             self.assertEqual(tree_revision, revision)
 
@@ -100,7 +99,7 @@
         self.addCleanup(tree.unlock)
         path = tree.id2path('sub-root')
         self.assertEqual('sub-1',
-            tree.get_reference_revision('sub-root', path))
+            tree.get_reference_revision(path, 'sub-root'))
 
     def test_iter_references(self):
         tree = self.create_nested()
@@ -149,12 +148,10 @@
         tree = self.make_branch_and_tree('tree')
         work_tree = self.make_branch_and_tree('wt')
         tree = self.get_tree_no_parents_abc_content(work_tree)
-        a_id = tree.path2id('a')
-        b_id = tree.path2id('b')
         tree.lock_read()
         self.addCleanup(tree.unlock)
-        self.assertEqual('file', tree.stored_kind(a_id))
-        self.assertEqual('directory', tree.stored_kind(b_id))
+        self.assertEqual('file', tree.stored_kind('a'))
+        self.assertEqual('directory', tree.stored_kind('b'))
 
 
 class TestFileContent(TestCaseWithTree):
@@ -166,14 +163,14 @@
         tree.lock_read()
         self.addCleanup(tree.unlock)
         # Test lookup without path works
-        file_without_path = tree.get_file(a_id)
+        file_without_path = tree.get_file('a')
         try:
             lines = file_without_path.readlines()
             self.assertEqual(['foobar\n'], lines)
         finally:
             file_without_path.close()
         # Test lookup with path works
-        file_with_path = tree.get_file(a_id, path='a')
+        file_with_path = tree.get_file('a', a_id)
         try:
             lines = file_with_path.readlines()
             self.assertEqual(['foobar\n'], lines)
@@ -187,9 +184,9 @@
         tree.lock_read()
         self.addCleanup(tree.unlock)
         # test read by file-id
-        self.assertEqual('foobar\n', tree.get_file_text(a_id))
+        self.assertEqual('foobar\n', tree.get_file_text('a', a_id))
         # test read by path
-        self.assertEqual('foobar\n', tree.get_file_text(a_id, path='a'))
+        self.assertEqual('foobar\n', tree.get_file_text('a'))
 
     def test_get_file_lines(self):
         work_tree = self.make_branch_and_tree('wt')
@@ -198,9 +195,9 @@
         tree.lock_read()
         self.addCleanup(tree.unlock)
         # test read by file-id
-        self.assertEqual(['foobar\n'], tree.get_file_lines(a_id))
+        self.assertEqual(['foobar\n'], tree.get_file_lines('a', a_id))
         # test read by path
-        self.assertEqual(['foobar\n'], tree.get_file_lines(a_id, path='a'))
+        self.assertEqual(['foobar\n'], tree.get_file_lines('a'))
 
     def test_get_file_lines_multi_line_breaks(self):
         work_tree = self.make_branch_and_tree('wt')
@@ -210,7 +207,7 @@
         tree.lock_read()
         self.addCleanup(tree.unlock)
         self.assertEqual(['a\rb\n', 'c\r\n', 'd'],
-                         tree.get_file_lines(tree.path2id('foobar')))
+                         tree.get_file_lines('foobar'))
 
 
 class TestExtractFilesBytes(TestCaseWithTree):
@@ -324,7 +321,7 @@
         tree.lock_read()
         self.addCleanup(tree.unlock)
         expected = osutils.sha_strings('file content')
-        self.assertEqual(expected, tree.get_file_sha1(tree.path2id('file')))
+        self.assertEqual(expected, tree.get_file_sha1('file'))
 
 
 class TestGetFileVerifier(TestCaseWithTree):
@@ -338,10 +335,10 @@
         tree = self._convert_tree(work_tree)
         tree.lock_read()
         self.addCleanup(tree.unlock)
-        (kind, data) = tree.get_file_verifier(tree.path2id('file1'))
+        (kind, data) = tree.get_file_verifier('file1')
         self.assertEqual(
-            tree.get_file_verifier(tree.path2id('file1')),
-            tree.get_file_verifier(tree.path2id('file2')))
+            tree.get_file_verifier('file1'),
+            tree.get_file_verifier('file2'))
         if kind == "SHA1":
             expected = osutils.sha_strings('file content')
             self.assertEqual(expected, data)

=== modified file 'breezy/tests/per_workingtree/test_add.py'
--- breezy/tests/per_workingtree/test_add.py	2017-10-08 02:49:53 +0000
+++ breezy/tests/per_workingtree/test_add.py	2017-11-19 19:02:26 +0000
@@ -46,7 +46,7 @@
         """Adding an entry with a pre-existing id raises DuplicateFileId"""
         tree = self.make_branch_and_tree('.')
         if not tree.supports_setting_file_ids():
-            self.skip("tree does not support setting file ids")
+            self.skipTest("tree does not support setting file ids")
         self.build_tree(['a', 'b'])
         tree.add(['a'])
         self.assertRaises(errors.DuplicateFileId,
@@ -64,7 +64,7 @@
         tree.commit('first')
         root_id = tree.get_root_id()
         # And the entry should not have been added.
-        tree.unversion([file_id])
+        tree.unversion(['a'])
         tree.add(['b'], [file_id])
         self.assertTreeLayout([('', root_id), ('b', file_id)], tree)
         self.assertTreeLayout([('', root_id), ('a', file_id)],
@@ -103,7 +103,7 @@
     def test_add_subdir_with_ids(self):
         tree = self.make_branch_and_tree('.')
         if not tree.supports_setting_file_ids():
-            self.skip("tree does not support setting file ids")
+            self.skipTest("tree does not support setting file ids")
         self.build_tree(['dir/', 'dir/subdir/', 'dir/subdir/foo'])
         tree.add(['dir'], ['dir-id'])
         tree.add(['dir/subdir'], ['subdir-id'])
@@ -143,7 +143,7 @@
     def test_add_multiple_with_file_ids(self):
         tree = self.make_branch_and_tree('.')
         if not tree.supports_setting_file_ids():
-            self.skip("tree does not support setting file ids")
+            self.skipTest("tree does not support setting file ids")
         self.build_tree(['a', 'b', 'dir/', 'dir/subdir/', 'dir/subdir/foo'])
         tree.add(['a', 'b', 'dir', 'dir/subdir', 'dir/subdir/foo'],
                  ['a-id', 'b-id', 'dir-id', 'subdir-id', 'foo-id'])
@@ -168,7 +168,7 @@
         root_id = tree.get_root_id()
         tree.add(['dir'])
         tree.commit('dir')
-        tree.unversion([tree.path2id('dir')])
+        tree.unversion(['dir'])
         self.assertRaises(errors.NotVersionedError,
                           tree.add, ['dir/subdir'])
 
@@ -188,7 +188,7 @@
         tree = self.make_branch_and_tree('.')
         self.build_tree(['foo'])
         tree.add(['foo'])
-        tree.unversion([tree.path2id('foo')])
+        tree.unversion(['foo'])
         tree.add(['foo'])
         self.assertTrue(tree.has_filename('foo'))
 
@@ -196,10 +196,10 @@
         # adding a path that was previously added should work
         tree = self.make_branch_and_tree('.')
         if not tree.supports_setting_file_ids():
-            self.skip("tree does not support setting file ids")
+            self.skipTest("tree does not support setting file ids")
         self.build_tree(['foo'])
         tree.add(['foo'], ['foo-id'])
-        tree.unversion(['foo-id'])
+        tree.unversion(['foo'])
         tree.add(['foo'], ['foo-id'])
         self.assertEqual('foo-id', tree.path2id('foo'))
 
@@ -209,7 +209,7 @@
         self.build_tree(['foo'])
         tree.add(['foo'])
         tree.commit('add foo')
-        tree.unversion([tree.path2id('foo')])
+        tree.unversion(['foo'])
         tree.add(['foo'])
         self.assertTrue(tree.has_filename('foo'))
 
@@ -217,10 +217,10 @@
         # adding a path that was present in the basis should work.
         tree = self.make_branch_and_tree('.')
         if not tree.supports_setting_file_ids():
-            self.skip("tree does not support setting file ids")
+            self.skipTest("tree does not support setting file ids")
         self.build_tree(['foo'])
         tree.add(['foo'], ['foo-id'])
         tree.commit('add foo')
-        tree.unversion(['foo-id'])
+        tree.unversion(['foo'])
         tree.add(['foo'], ['foo-id'])
         self.assertEqual('foo-id', tree.path2id('foo'))

=== modified file 'breezy/tests/per_workingtree/test_add_reference.py'
--- breezy/tests/per_workingtree/test_add_reference.py	2017-10-26 11:12:08 +0000
+++ breezy/tests/per_workingtree/test_add_reference.py	2017-11-19 19:02:26 +0000
@@ -52,15 +52,15 @@
         tree.lock_write()
         try:
             self.assertEqual(tree.path2id('sub-tree'), sub_tree_root_id)
-            self.assertEqual(tree.kind(sub_tree_root_id), 'tree-reference')
+            self.assertEqual(tree.kind('sub-tree'), 'tree-reference')
             tree.commit('commit reference')
             basis = tree.basis_tree()
             basis.lock_read()
             try:
-                sub_tree = tree.get_nested_tree(sub_tree_root_id)
+                sub_tree = tree.get_nested_tree('sub-tree', sub_tree_root_id)
                 self.assertEqual(
                         sub_tree.last_revision(),
-                        tree.get_reference_revision(sub_tree_root_id))
+                        tree.get_reference_revision('sub-tree', sub_tree_root_id))
             finally:
                 basis.unlock()
         finally:
@@ -108,8 +108,9 @@
         sub_tree_root_id = sub_tree.get_root_id()
         tree.lock_read()
         try:
-            sub_tree2 = tree.get_nested_tree(sub_tree_root_id)
-            self.assertEqual(sub_tree.basedir, sub_tree2.basedir)
-            sub_tree2 = tree.get_nested_tree(sub_tree_root_id, 'sub-tree')
+            sub_tree2 = tree.get_nested_tree('sub-tree', sub_tree_root_id)
+            self.assertEqual(sub_tree.basedir, sub_tree2.basedir)
+            sub_tree2 = tree.get_nested_tree('sub-tree')
+            self.assertEqual(sub_tree.basedir, sub_tree2.basedir)
         finally:
             tree.unlock()

=== modified file 'breezy/tests/per_workingtree/test_annotate_iter.py'
--- breezy/tests/per_workingtree/test_annotate_iter.py	2017-11-16 00:39:04 +0000
+++ breezy/tests/per_workingtree/test_annotate_iter.py	2017-11-19 19:02:26 +0000
@@ -35,7 +35,7 @@
 
     def test_annotate_same_as_parent(self):
         tree = self.make_single_rev_tree()
-        annotations = tree.annotate_iter('file-id')
+        annotations = tree.annotate_iter('file')
         self.assertEqual([('rev-1', 'initial content\n')],
                          annotations)
 
@@ -43,7 +43,7 @@
         tree = self.make_single_rev_tree()
         self.build_tree_contents([('tree/file',
                                    'initial content\nnew content\n')])
-        annotations = tree.annotate_iter('file-id')
+        annotations = tree.annotate_iter('file')
         self.assertEqual([('rev-1', 'initial content\n'),
                           ('current:', 'new content\n'),
                          ], annotations)
@@ -70,7 +70,7 @@
         self.build_tree_contents([('tree/file',
                                    'initial content\ncontent in 2\n'
                                    'content in 3\nnew content\n')])
-        annotations = tree.annotate_iter('file-id')
+        annotations = tree.annotate_iter('file')
         self.assertEqual([('rev-1', 'initial content\n'),
                           ('rev-2', 'content in 2\n'),
                           ('rev-3', 'content in 3\n'),
@@ -95,7 +95,7 @@
         tree.set_parent_ids(['rev-2', 'rev-3'])
         self.build_tree_contents([('tree/file',
                                    'initial content\nnew content\n')])
-        annotations = tree.annotate_iter('file-id')
+        annotations = tree.annotate_iter('file')
         self.assertEqual([('rev-2', 'initial content\n'),
                           ('current:', 'new content\n'),
                          ], annotations)
@@ -120,7 +120,7 @@
         tree.set_parent_ids(['rev-2', 'rev-3'])
         self.build_tree_contents([('tree/file',
                                    'initial content\nnew content\n')])
-        annotations = tree.annotate_iter('file-id')
+        annotations = tree.annotate_iter('file')
         self.assertEqual([('rev-2', 'initial content\n'),
                           ('current:', 'new content\n'),
                          ], annotations)
@@ -145,7 +145,7 @@
         tree.set_parent_ids(['rev-2', 'rev-3'])
         self.build_tree_contents([('tree/file',
                                    'initial content\ncontent in 3\n')])
-        annotations = tree.annotate_iter('file-id')
+        annotations = tree.annotate_iter('file')
         self.assertEqual([('rev-1', 'initial content\n'),
                           ('rev-3', 'content in 3\n'),
                          ], annotations)
@@ -174,7 +174,7 @@
         tree.lock_write()
         self.addCleanup(tree.unlock)
         tree.set_parent_ids(['rev-2', 'rev-4'])
-        annotations = tree.annotate_iter('file-id')
+        annotations = tree.annotate_iter('file')
         self.assertEqual([('rev-1', 'initial content\n'),
                           ('rev-4', 'new content\n'),
                          ], annotations)

=== modified file 'breezy/tests/per_workingtree/test_basis_tree.py'
--- breezy/tests/per_workingtree/test_basis_tree.py	2017-05-21 18:10:28 +0000
+++ breezy/tests/per_workingtree/test_basis_tree.py	2017-11-19 19:02:26 +0000
@@ -59,7 +59,7 @@
 
         self.build_tree(['new file', 'new dir/'])
         tree.rename_one('file', 'dir/new file')
-        tree.unversion([tree.path2id('dir/subfile')])
+        tree.unversion(['dir/subfile'])
         tree.add(['new file', 'new dir'])
 
         basis_tree = tree.basis_tree()

=== modified file 'breezy/tests/per_workingtree/test_commit.py'
--- breezy/tests/per_workingtree/test_commit.py	2017-08-10 00:51:26 +0000
+++ breezy/tests/per_workingtree/test_commit.py	2017-11-19 19:02:26 +0000
@@ -390,8 +390,9 @@
         sub_basis = subtree.basis_tree()
         sub_basis.lock_read()
         self.addCleanup(sub_basis.unlock)
-        self.assertEqual(subsubtree.last_revision(),
-            sub_basis.get_reference_revision(sub_basis.path2id('subtree')))
+        self.assertEqual(
+                subsubtree.last_revision(),
+                sub_basis.get_reference_revision('subtree'))
         # the intermediate tree has changed, so should have had a commit
         # take place.
         self.assertNotEqual(None, subtree.last_revision())
@@ -401,7 +402,7 @@
         basis.lock_read()
         self.addCleanup(basis.unlock)
         self.assertEqual(subtree.last_revision(),
-            basis.get_reference_revision(basis.path2id('subtree')))
+            basis.get_reference_revision('subtree'))
         # the outer tree must have have changed too.
         self.assertNotEqual(None, rev_id)
 
@@ -417,7 +418,7 @@
         self.build_tree(['subtree/file'])
         subtree.add(['file'])
         rev_id = tree.commit('added reference', allow_pointless=False)
-        tree.get_reference_revision(tree.path2id('subtree'))
+        tree.get_reference_revision('subtree')
         child_revid = subtree.last_revision()
         # now change the child tree
         self.build_tree_contents([('subtree/file', 'new-content')])
@@ -435,7 +436,7 @@
         basis.lock_read()
         self.addCleanup(basis.unlock)
         self.assertEqual(subtree.last_revision(),
-            basis.get_reference_revision(basis.path2id('subtree')))
+            basis.get_reference_revision('subtree'))
         self.assertNotEqual(rev_id, rev_id2)
 
     def test_nested_pointless_commits_are_pointless(self):

=== modified file 'breezy/tests/per_workingtree/test_content_filters.py'
--- breezy/tests/per_workingtree/test_content_filters.py	2017-05-21 18:10:28 +0000
+++ breezy/tests/per_workingtree/test_content_filters.py	2017-11-19 19:02:26 +0000
@@ -136,7 +136,9 @@
         basis = branch.basis_tree()
         basis.lock_read()
         try:
-            self.assertEqual(expected_content, basis.get_file_text(file_id))
+            self.assertEqual(
+                    expected_content,
+                    basis.get_file_text(basis.id2path(file_id), file_id))
         finally:
             basis.unlock()
 
@@ -152,14 +154,18 @@
             expected = "fOO tXT"
         else:
             expected = "Foo Txt"
-        self.assertEqual(expected, basis.get_file_text(txt_fileid))
-        self.assertEqual('Foo Bin', basis.get_file_text(bin_fileid))
+        self.assertEqual(
+                expected,
+                basis.get_file_text(basis.id2path(txt_fileid)))
+        self.assertEqual(
+                'Foo Bin',
+                basis.get_file_text(basis.id2path(bin_fileid)))
         # Check that the working tree has the original content
         tree.lock_read()
         self.addCleanup(tree.unlock)
-        self.assertEqual('Foo Txt', tree.get_file(txt_fileid,
+        self.assertEqual('Foo Txt', tree.get_file(tree.id2path(txt_fileid),
             filtered=False).read())
-        self.assertEqual('Foo Bin', tree.get_file(bin_fileid,
+        self.assertEqual('Foo Bin', tree.get_file(tree.id2path(bin_fileid),
             filtered=False).read())
 
     def test_readonly_content_filtering(self):
@@ -174,14 +180,14 @@
             expected = "FOO TXT"
         else:
             expected = "Foo Txt"
-        self.assertEqual(expected, basis.get_file_text(txt_fileid))
-        self.assertEqual('Foo Bin', basis.get_file_text(bin_fileid))
+        self.assertEqual(expected, basis.get_file_text(basis.id2path(txt_fileid)))
+        self.assertEqual('Foo Bin', basis.get_file_text(basis.id2path(bin_fileid)))
         # We expect the workingtree content to be unchanged (for now at least)
         tree.lock_read()
         self.addCleanup(tree.unlock)
-        self.assertEqual('Foo Txt', tree.get_file(txt_fileid,
+        self.assertEqual('Foo Txt', tree.get_file(tree.id2path(txt_fileid),
             filtered=False).read())
-        self.assertEqual('Foo Bin', tree.get_file(bin_fileid,
+        self.assertEqual('Foo Bin', tree.get_file(tree.id2path(bin_fileid),
             filtered=False).read())
 
     def test_branch_source_filtered_target_not(self):
@@ -237,9 +243,11 @@
         self.addCleanup(source.unlock)
 
         expected_canonical_form = 'Foo Txt\nend string\n'
-        self.assertEqual(source.get_file(txt_fileid, filtered=True).read(),
+        self.assertEqual(
+            source.get_file(source.id2path(txt_fileid), filtered=True).read(),
             expected_canonical_form)
-        self.assertEqual(source.get_file(txt_fileid, filtered=False).read(),
+        self.assertEqual(
+            source.get_file(source.id2path(txt_fileid), filtered=False).read(),
             'Foo Txt')
 
         # results are: kind, size, executable, sha1_or_link_target

=== modified file 'breezy/tests/per_workingtree/test_eol_conversion.py'
--- breezy/tests/per_workingtree/test_eol_conversion.py	2017-06-10 00:17:06 +0000
+++ breezy/tests/per_workingtree/test_eol_conversion.py	2017-11-19 19:02:26 +0000
@@ -92,7 +92,7 @@
         self.patch_rules_searcher(eol)
         wt2 = wt.controldir.sprout('tree-%s' % eol).open_workingtree()
         # To see exactly what got written to disk, we need an unfiltered read
-        content = wt2.get_file('file1-id', filtered=False).read()
+        content = wt2.get_file('file1', filtered=False).read()
         if sys.platform == 'win32':
             self.assertEqual(expected_win, content)
         else:
@@ -110,7 +110,7 @@
         :param roundtrip_to: the set of formats (excluding exact) we
           can round-trip to or None for all
         """
-        basis_content = basis.get_file('file1-id').read()
+        basis_content = basis.get_file('file1').read()
         self.assertEqual(expected_raw, basis_content)
 
         # No setting and exact should always roundtrip

=== modified file 'breezy/tests/per_workingtree/test_executable.py'
--- breezy/tests/per_workingtree/test_executable.py	2017-06-10 00:17:06 +0000
+++ breezy/tests/per_workingtree/test_executable.py	2017-11-19 19:02:26 +0000
@@ -43,9 +43,9 @@
     def check_exist(self, tree):
         """Just check that both files have the right executable bits set"""
         tree.lock_read()
-        self.assertTrue(tree.is_executable(self.a_id),
+        self.assertTrue(tree.is_executable('a'),
                         "'a' lost the execute bit")
-        self.assertFalse(tree.is_executable(self.b_id),
+        self.assertFalse(tree.is_executable('b'),
                     "'b' gained an execute bit")
         tree.unlock()
 
@@ -190,5 +190,5 @@
     def test_use_exec_from_basis(self):
         self.wt._supports_executable = lambda: False
         self.addCleanup(self.wt.lock_read().unlock)
-        self.assertTrue(self.wt.is_executable(self.a_id))
-        self.assertFalse(self.wt.is_executable(self.b_id))
+        self.assertTrue(self.wt.is_executable('a'))
+        self.assertFalse(self.wt.is_executable('b'))

=== modified file 'breezy/tests/per_workingtree/test_get_file_mtime.py'
--- breezy/tests/per_workingtree/test_get_file_mtime.py	2017-10-08 02:49:53 +0000
+++ breezy/tests/per_workingtree/test_get_file_mtime.py	2017-11-19 19:02:26 +0000
@@ -43,10 +43,10 @@
         st = os.lstat('tree/one')
         tree.lock_read()
         try:
-            mtime_file_id = tree.get_file_mtime(file_id=one_id)
+            mtime_file_id = tree.get_file_mtime('one')
             self.assertIsInstance(mtime_file_id, (float, int))
             self.assertAlmostEqual(st.st_mtime, mtime_file_id)
-            mtime_path = tree.get_file_mtime(file_id=one_id, path='one')
+            mtime_path = tree.get_file_mtime('one', file_id=one_id)
             self.assertAlmostEqual(mtime_file_id, mtime_path)
         finally:
             tree.unlock()
@@ -61,10 +61,10 @@
 
         tree.lock_read()
         try:
-            mtime = tree.get_file_mtime(file_id=one_id)
+            mtime = tree.get_file_mtime('one')
             self.assertAlmostEqual(st.st_mtime, mtime)
 
-            mtime = tree.get_file_mtime(file_id=one_id, path='one')
+            mtime = tree.get_file_mtime('one', one_id)
             self.assertAlmostEqual(st.st_mtime, mtime)
         finally:
             tree.unlock()
@@ -79,9 +79,9 @@
 
         tree.lock_read()
         try:
-            mtime = tree.get_file_mtime(file_id=one_id)
+            mtime = tree.get_file_mtime('two')
             self.assertAlmostEqual(st.st_mtime, mtime)
-            mtime = tree.get_file_mtime(file_id=one_id, path='two')
+            mtime = tree.get_file_mtime('two', one_id)
             self.assertAlmostEqual(st.st_mtime, mtime)
         finally:
             tree.unlock()
@@ -98,9 +98,9 @@
         st = os.lstat('tree/e/a')
         tree.lock_read()
         try:
-            mtime = tree.get_file_mtime(file_id='a-id')
+            mtime = tree.get_file_mtime('e/a')
             self.assertAlmostEqual(st.st_mtime, mtime)
-            mtime = tree.get_file_mtime(file_id='a-id', path='e/a')
+            mtime = tree.get_file_mtime('e/a', 'a-id')
             self.assertAlmostEqual(st.st_mtime, mtime)
         finally:
             tree.unlock()
@@ -112,8 +112,7 @@
         os.remove('tree/one')
         tree.lock_read()
         try:
-            self.assertRaises(FileTimestampUnavailable,
-                tree.get_file_mtime, file_id=one_id)
+            self.assertRaises(errors.NoSuchFile, tree.get_file_mtime, 'one')
         finally:
             tree.unlock()
 

=== modified file 'breezy/tests/per_workingtree/test_merge_from_branch.py'
--- breezy/tests/per_workingtree/test_merge_from_branch.py	2017-11-16 00:39:04 +0000
+++ breezy/tests/per_workingtree/test_merge_from_branch.py	2017-11-19 19:02:26 +0000
@@ -103,7 +103,7 @@
     def test_merge_type(self):
         this = self.make_branch_and_tree('this')
         self.build_tree_contents([('this/foo', 'foo')])
-        this.add('foo', 'foo-id')
+        this.add('foo')
         this.commit('added foo')
         other = this.controldir.sprout('other').open_workingtree()
         self.build_tree_contents([('other/foo', 'bar')])
@@ -114,7 +114,7 @@
             def text_merge(self, file_id, trans_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-id'))
+        self.assertEqual('qux', this.get_file_text('foo'))
 
 
 class TestMergedBranch(per_workingtree.TestCaseWithWorkingTree):

=== modified file 'breezy/tests/per_workingtree/test_mkdir.py'
--- breezy/tests/per_workingtree/test_mkdir.py	2017-05-21 18:10:28 +0000
+++ breezy/tests/per_workingtree/test_mkdir.py	2017-11-19 19:02:26 +0000
@@ -27,7 +27,7 @@
         t.lock_write()
         self.addCleanup(t.unlock)
         file_id = t.mkdir('path')
-        self.assertEqual('directory', t.kind(file_id))
+        self.assertEqual('directory', t.kind('path', file_id))
 
     def test_mkdir_with_id(self):
         t = self.make_branch_and_tree('t1')
@@ -35,4 +35,4 @@
         self.addCleanup(t.unlock)
         file_id = t.mkdir('path', 'my-id')
         self.assertEqual('my-id', file_id)
-        self.assertEqual('directory', t.kind(file_id))
+        self.assertEqual('directory', t.kind('path', file_id))

=== modified file 'breezy/tests/per_workingtree/test_move.py'
--- breezy/tests/per_workingtree/test_move.py	2017-08-07 19:09:47 +0000
+++ breezy/tests/per_workingtree/test_move.py	2017-11-19 19:02:26 +0000
@@ -160,7 +160,7 @@
                                ('b/c', 'c-id')], tree)
         self.assertTreeLayout([('', root_id), ('a', 'a-id'), ('b/', 'b-id'),
                                ('b/c', 'c-id')], tree.basis_tree())
-        a_contents = tree.get_file_text('a-id')
+        a_contents = tree.get_file_text('a', 'a-id')
         self.assertEqual([('a', 'b/a')],
             tree.move(['a'], 'b'))
         self.assertTreeLayout([('', root_id), ('b/', 'b-id'), ('b/a', 'a-id'),
@@ -177,7 +177,7 @@
         tree.add(['a', 'b', 'b/c'], ['a-id', 'b-id', 'c-id'])
         tree.commit('initial')
         root_id = tree.get_root_id()
-        c_contents = tree.get_file_text('c-id')
+        c_contents = tree.get_file_text('b/c', 'c-id')
         self.assertEqual([('b/c', 'c')],
             tree.move(['b/c'], ''))
         self.assertTreeLayout([('', root_id), ('a', 'a-id'), ('b/', 'b-id'),

=== modified file 'breezy/tests/per_workingtree/test_nested_specifics.py'
--- breezy/tests/per_workingtree/test_nested_specifics.py	2017-06-10 16:40:42 +0000
+++ breezy/tests/per_workingtree/test_nested_specifics.py	2017-11-19 19:02:26 +0000
@@ -64,7 +64,7 @@
 
     def test_kind_does_not_autodetect_subtree(self):
         tree = self.prepare_with_subtree()
-        self.assertEqual('directory', tree.kind('subtree-id'))
+        self.assertEqual('directory', tree.kind('subtree', 'subtree-id'))
 
     def test_comparison_data_does_not_autodetect_subtree(self):
         tree = self.prepare_with_subtree()
@@ -75,7 +75,7 @@
 
     def test_inventory_does_not_autodetect_subtree(self):
         tree = self.prepare_with_subtree()
-        self.assertEqual('directory', tree.kind('subtree-id'))
+        self.assertEqual('directory', tree.kind('subtree', 'subtree-id'))
 
     def test_iter_entries_by_dir_autodetects_subtree(self):
         tree = self.prepare_with_subtree()

=== modified file 'breezy/tests/per_workingtree/test_parents.py'
--- breezy/tests/per_workingtree/test_parents.py	2017-06-11 01:22:16 +0000
+++ breezy/tests/per_workingtree/test_parents.py	2017-11-19 19:02:26 +0000
@@ -250,9 +250,9 @@
         tree.lock_read()
         self.addCleanup(tree.unlock)
         # Check that the symlink target is safely round-tripped in the trees.
-        self.assertEqual(target, tree.get_symlink_target('link-id'))
+        self.assertEqual(target, tree.get_symlink_target(link_name))
         basis = tree.basis_tree()
-        self.assertEqual(target, basis.get_symlink_target('link-id'))
+        self.assertEqual(target, basis.get_symlink_target(link_name))
 
 
 class TestAddParent(TestParents):
@@ -395,14 +395,16 @@
                 self._repository = tree.branch.repository
                 self._inventory = shape
 
-            def get_file_text(self, file_id, path=None):
+            def get_file_text(self, path, file_id=None):
+                if file_id is None:
+                    file_id = self.path2id(path)
                 ie = self.root_inventory[file_id]
                 if ie.kind != "file":
                     return ""
                 return 'a' * ie.text_size
 
-            def get_file(self, file_id, path=None):
-                return BytesIO(self.get_file_text(file_id))
+            def get_file(self, path, file_id=None):
+                return BytesIO(self.get_file_text(path, file_id))
 
         tree.lock_write()
         try:

=== modified file 'breezy/tests/per_workingtree/test_paths2ids.py'
--- breezy/tests/per_workingtree/test_paths2ids.py	2017-06-10 00:17:06 +0000
+++ breezy/tests/per_workingtree/test_paths2ids.py	2017-11-19 19:02:26 +0000
@@ -137,7 +137,7 @@
                  ['dir', 'child-moves', 'child-stays', 'child-goes'])
         tree.commit('create basis')
         basis = tree.basis_tree()
-        tree.unversion(['child-goes'])
+        tree.unversion(['dir/child-goes'])
         tree.rename_one('dir/child-moves', 'child-moves')
         self.build_tree(['tree/newdir/'])
         tree.add(['newdir'], ['newdir'])

=== modified file 'breezy/tests/per_workingtree/test_put_file.py'
--- breezy/tests/per_workingtree/test_put_file.py	2017-05-21 18:10:28 +0000
+++ breezy/tests/per_workingtree/test_put_file.py	2017-11-19 19:02:26 +0000
@@ -24,14 +24,14 @@
 
     def test_put_new_file(self):
         t = self.make_branch_and_tree('t1')
-        t.add(['foo'], ids=['foo-id'], kinds=['file'])
-        t.put_file_bytes_non_atomic('foo-id', 'barshoom')
-        self.assertEqual('barshoom', t.get_file('foo-id').read())
+        t.add(['foo'], kinds=['file'])
+        t.put_file_bytes_non_atomic('foo', 'barshoom')
+        self.assertEqual('barshoom', t.get_file('foo').read())
 
     def test_put_existing_file(self):
         t = self.make_branch_and_tree('t1')
-        t.add(['foo'], ids=['foo-id'], kinds=['file'])
-        t.put_file_bytes_non_atomic('foo-id', 'first-content')
-        t.put_file_bytes_non_atomic('foo-id', 'barshoom')
-        self.assertEqual('barshoom', t.get_file('foo-id').read())
+        t.add(['foo'], kinds=['file'])
+        t.put_file_bytes_non_atomic('foo', 'first-content')
+        t.put_file_bytes_non_atomic('foo', 'barshoom')
+        self.assertEqual('barshoom', t.get_file('foo').read())
 

=== modified file 'breezy/tests/per_workingtree/test_readonly.py'
--- breezy/tests/per_workingtree/test_readonly.py	2017-06-10 12:49:41 +0000
+++ breezy/tests/per_workingtree/test_readonly.py	2017-11-19 19:02:26 +0000
@@ -110,7 +110,7 @@
                 tree._dirstate._sha_cutoff_time = self._custom_cutoff_time
             # Make sure we check all the files
             for file_id in tree.all_file_ids():
-                size = tree.get_file_size(file_id)
-                sha1 = tree.get_file_sha1(file_id)
+                size = tree.get_file_size(tree.id2path(file_id))
+                sha1 = tree.get_file_sha1(tree.id2path(file_id))
         finally:
             tree.unlock()

=== modified file 'breezy/tests/per_workingtree/test_rename_one.py'
--- breezy/tests/per_workingtree/test_rename_one.py	2017-08-29 23:18:16 +0000
+++ breezy/tests/per_workingtree/test_rename_one.py	2017-11-19 19:02:26 +0000
@@ -81,7 +81,7 @@
         tree.commit('initial')
         root_id = tree.get_root_id()
 
-        a_contents = tree.get_file_text(a_id)
+        a_contents = tree.get_file_text('a', a_id)
         tree.rename_one('a', 'foo')
         self.assertTreeLayout([('', root_id), ('b/', b_id), ('foo', a_id)],
                               tree)
@@ -99,7 +99,7 @@
         tree.commit('initial')
         root_id = tree.get_root_id()
 
-        a_contents = tree.get_file_text(a_id)
+        a_contents = tree.get_file_text('a', a_id)
         tree.rename_one('a', 'b/foo')
         self.assertTreeLayout([('', root_id), ('b/', b_id), ('b/foo', a_id)],
                               tree)
@@ -121,7 +121,7 @@
                                ('b/c', c_id)], tree)
         self.assertTreeLayout([('', root_id), ('a', a_id), ('b/', b_id),
                                ('b/c', c_id)], tree.basis_tree())
-        a_contents = tree.get_file_text(a_id)
+        a_contents = tree.get_file_text('a', a_id)
         tree.rename_one('a', 'b/d')
         self.assertTreeLayout([('', root_id), ('b/', b_id), ('b/c', c_id),
                                ('b/d', a_id)], tree)
@@ -139,7 +139,7 @@
         c_id = tree.path2id('b/c')
         tree.commit('initial')
         root_id = tree.get_root_id()
-        c_contents = tree.get_file_text(c_id)
+        c_contents = tree.get_file_text('b/c', c_id)
         tree.rename_one('b/c', 'd')
         self.assertTreeLayout([('', root_id), ('a', a_id), ('b/', b_id),
                                ('d', c_id)], tree)

=== modified file 'breezy/tests/per_workingtree/test_revision_tree.py'
--- breezy/tests/per_workingtree/test_revision_tree.py	2017-06-10 00:17:06 +0000
+++ breezy/tests/per_workingtree/test_revision_tree.py	2017-11-19 19:02:26 +0000
@@ -119,9 +119,9 @@
         basis = tree.revision_tree(parents[0])
         basis.lock_read()
         self.addCleanup(basis.unlock)
-        self.assertRaises(errors.NoSuchId, basis.kind, 'a-id')
+        self.assertRaises(errors.NoSuchId, basis.kind, 'a')
         self.assertEqual(['directory', 'file'],
-                         [basis.kind('b-id'), basis.kind('c-id')])
+                         [basis.kind('b'), basis.kind('b/c')])
         try:
             other = tree.revision_tree(parents[1])
         except errors.NoSuchRevisionInTree:
@@ -130,6 +130,6 @@
                 % type(tree))
         other.lock_read()
         self.addCleanup(other.unlock)
-        self.assertRaises(errors.NoSuchId, other.kind, 'b-id')
-        self.assertRaises(errors.NoSuchId, other.kind, 'c-id')
-        self.assertEqual('file', other.kind('a-id'))
+        self.assertRaises(errors.NoSuchId, other.kind, 'b')
+        self.assertRaises(errors.NoSuchId, other.kind, 'c')
+        self.assertEqual('file', other.kind('a'))

=== modified file 'breezy/tests/per_workingtree/test_symlinks.py'
--- breezy/tests/per_workingtree/test_symlinks.py	2017-05-21 18:10:28 +0000
+++ breezy/tests/per_workingtree/test_symlinks.py	2017-11-19 19:02:26 +0000
@@ -44,8 +44,7 @@
         tree.smart_add(['tree/link'])
         self.assertIsNot(None, tree.path2id('link'))
         self.assertIs(None, tree.path2id('target'))
-        self.assertEqual('symlink',
-            tree.kind(tree.path2id('link')))
+        self.assertEqual('symlink', tree.kind('link'))
 
     def test_smart_add_symlink_pointing_outside(self):
         tree = self.make_branch_and_tree('tree')
@@ -55,8 +54,7 @@
         tree.smart_add(['tree/link'])
         self.assertIsNot(None, tree.path2id('link'))
         self.assertIs(None, tree.path2id('target'))
-        self.assertEqual('symlink',
-            tree.kind(tree.path2id('link')))
+        self.assertEqual('symlink', tree.kind('link'))
 
     def test_add_file_under_symlink(self):
         # similar to 

=== modified file 'breezy/tests/per_workingtree/test_unversion.py'
--- breezy/tests/per_workingtree/test_unversion.py	2017-06-10 00:17:06 +0000
+++ breezy/tests/per_workingtree/test_unversion.py	2017-11-19 19:02:26 +0000
@@ -32,9 +32,9 @@
         tree.unlock()
 
     def test_unversion_missing_file(self):
-        """WT.unversion(['missing-id']) raises NoSuchId."""
+        """WT.unversion(['missing']) raises NoSuchId."""
         tree = self.make_branch_and_tree('.')
-        self.assertRaises(errors.NoSuchId, tree.unversion, ['missing-id'])
+        self.assertRaises(errors.NoSuchFile, tree.unversion, ['missing'])
 
     def test_unversion_parent_and_child_renamed_bug_187207(self):
         # When unversioning dirstate trees show a bug in dealing with
@@ -47,7 +47,7 @@
         tree.commit('setup')
         tree.rename_one('del/sub', 'sub')
         self.assertEqual('sub/b', tree.id2path('b'))
-        tree.unversion(['del', 'b'])
+        tree.unversion(['del', 'sub/b'])
         self.assertRaises(errors.NoSuchId, tree.id2path, 'b')
 
     def test_unversion_several_files(self):
@@ -57,7 +57,7 @@
         tree.add(['a', 'b', 'c'], ['a-id', 'b-id', 'c-id'])
         # within a lock unversion should take effect
         tree.lock_write()
-        tree.unversion(['a-id', 'b-id'])
+        tree.unversion(['a', 'b'])
         self.assertFalse(tree.has_id('a-id'))
         self.assertFalse(tree.has_id('b-id'))
         self.assertTrue(tree.has_id('c-id'))
@@ -84,7 +84,7 @@
         tree.add(['a', 'a/b', 'c'], ['a-id', 'b-id', 'c-id'])
         # within a lock unversion should take effect
         tree.lock_write()
-        tree.unversion(['a-id'])
+        tree.unversion(['a'])
         self.assertFalse(tree.has_id('a-id'))
         self.assertFalse(tree.has_id('b-id'))
         self.assertTrue(tree.has_id('c-id'))
@@ -103,7 +103,7 @@
         tree.add(['a', 'a/b', 'a/c', 'd'], ['a-id', 'b-id', 'c-id', 'd-id'])
         tree.lock_write()
         try:
-            tree.unversion(['b-id', 'a-id'])
+            tree.unversion(['a/b', 'a'])
             self.assertFalse(tree.has_id('a-id'))
             self.assertFalse(tree.has_id('b-id'))
             self.assertFalse(tree.has_id('c-id'))
@@ -144,7 +144,7 @@
                           ('dir2/f3', 'f3-id'),
                          ], paths)
 
-        tree.unversion({'dir-id'})
+        tree.unversion({'dir'})
         paths = [(path, ie.file_id)
                  for path, ie in tree.iter_entries_by_dir()]
 
@@ -170,7 +170,7 @@
         self.build_tree(['B/xyz/'])
         tree_b.add(['xyz'], ['xyz-id'])
         tree_b.rename_one('a/m', 'xyz/m')
-        tree_b.unversion(['a-id'])
+        tree_b.unversion(['a'])
         tree_b.commit('delete in B')
 
         paths = [(path, ie.file_id)
@@ -196,7 +196,7 @@
                           ('a/n.OTHER', 'n-id'),
                           ('xyz/m', 'm-id'),
                          ], paths)
-        tree_b.unversion(['a-id'])
+        tree_b.unversion(['a'])
         paths = [(path, ie.file_id)
                  for path, ie in tree_b.iter_entries_by_dir()]
         self.assertEqual([('', root_id),

=== modified file 'breezy/tests/per_workingtree/test_workingtree.py'
--- breezy/tests/per_workingtree/test_workingtree.py	2017-11-19 17:46:48 +0000
+++ breezy/tests/per_workingtree/test_workingtree.py	2017-11-19 19:02:26 +0000
@@ -912,11 +912,11 @@
         if has_symlinks():
             os.symlink('target', 'symlink')
             names.append('symlink')
-        tree.add(names, [n + '-id' for n in names])
+        tree.add(names)
         # now when we first look, we should see everything with the same kind
         # with which they were initially added
         for n in names:
-            actual_kind = tree.kind(n + '-id')
+            actual_kind = tree.kind(n)
             self.assertEqual(n, actual_kind)
         # move them around so the names no longer correspond to the types
         os.rename(names[0], 'tmp')
@@ -925,7 +925,7 @@
         os.rename('tmp', names[-1])
         # now look and expect to see the correct types again
         for i in range(len(names)):
-            actual_kind = tree.kind(names[i-1] + '-id')
+            actual_kind = tree.kind(names[i-1])
             expected_kind = names[i]
             self.assertEqual(expected_kind, actual_kind)
 
@@ -937,9 +937,9 @@
         tree.add(['a', 'b'])
         os.unlink('tree/a')
         os.rmdir('tree/b')
-        self.assertEqual('file', tree.stored_kind(tree.path2id('a')))
+        self.assertEqual('file', tree.stored_kind('a'))
         if tree.branch.repository._format.supports_versioned_directories:
-            self.assertEqual('directory', tree.stored_kind(tree.path2id('b')))
+            self.assertEqual('directory', tree.stored_kind('b'))
 
     def test_missing_file_sha1(self):
         """If a file is missing, its sha1 should be reported as None."""
@@ -950,22 +950,22 @@
         tree.add('file')
         tree.commit('file added')
         os.unlink('file')
-        self.assertIs(None, tree.get_file_sha1(tree.path2id('file')))
+        self.assertIs(None, tree.get_file_sha1('file'))
 
     def test_no_file_sha1(self):
-        """If a file is not present, get_file_sha1 should raise NoSuchId"""
+        """If a file is not present, get_file_sha1 should raise NoSuchFile"""
         tree = self.make_branch_and_tree('.')
         tree.lock_write()
         self.addCleanup(tree.unlock)
-        self.assertRaises(errors.NoSuchId, tree.get_file_sha1,
+        self.assertRaises(errors.NoSuchFile, tree.get_file_sha1,
                           'nonexistant')
         self.build_tree(['file'])
         tree.add('file')
         file_id = tree.path2id('file')
         tree.commit('foo')
         tree.remove('file')
-        self.assertRaises(errors.NoSuchId, tree.get_file_sha1,
-                          file_id)
+        self.assertRaises(errors.NoSuchFile, tree.get_file_sha1,
+                          'file')
 
     def test_case_sensitive(self):
         """If filesystem is case-sensitive, tree should report this.
@@ -1002,15 +1002,15 @@
         if tree._supports_executable():
             tree.lock_read()
             try:
-                self.assertFalse(tree.is_executable(tree.path2id('filename')))
+                self.assertFalse(tree.is_executable('filename'))
             finally:
                 tree.unlock()
             os.chmod('filename', 0o755)
             self.addCleanup(tree.lock_read().unlock)
-            self.assertTrue(tree.is_executable(tree.path2id('filename')))
+            self.assertTrue(tree.is_executable('filename'))
         else:
             self.addCleanup(tree.lock_read().unlock)
-            self.assertFalse(tree.is_executable(tree.path2id('filename')))
+            self.assertFalse(tree.is_executable('filename'))
 
     def test_all_file_ids_with_missing(self):
         tree = self.make_branch_and_tree('tree')

=== modified file 'breezy/tests/test_annotate.py'
--- breezy/tests/test_annotate.py	2017-11-16 00:39:04 +0000
+++ breezy/tests/test_annotate.py	2017-11-19 19:02:26 +0000
@@ -283,17 +283,17 @@
             self.assertEqualDiff(''.join('\t'.join(l) for l in expected),
                                  ''.join('\t'.join(l) for l in actual))
 
-    def assertBranchAnnotate(self, expected, branch, file_id, revision_id,
+    def assertBranchAnnotate(self, expected, branch, path, revision_id,
             verbose=False, full=False, show_ids=False):
         tree = branch.repository.revision_tree(revision_id)
         to_file = BytesIO()
-        annotate.annotate_file_tree(tree, file_id, to_file,
+        annotate.annotate_file_tree(tree, path, to_file,
             verbose=verbose, full=full, show_ids=show_ids, branch=branch)
         self.assertAnnotateEqualDiff(to_file.getvalue(), expected)
 
-    def assertRepoAnnotate(self, expected, repo, file_id, revision_id):
+    def assertRepoAnnotate(self, expected, repo, path, revision_id):
         """Assert that the revision is properly annotated."""
-        actual = list(repo.revision_tree(revision_id).annotate_iter(file_id))
+        actual = list(repo.revision_tree(revision_id).annotate_iter(path))
         self.assertAnnotateEqualDiff(actual, expected)
 
     def test_annotate_duplicate_lines(self):
@@ -302,12 +302,12 @@
         repo = builder.get_branch().repository
         repo.lock_read()
         self.addCleanup(repo.unlock)
-        self.assertRepoAnnotate(duplicate_base, repo, 'file-id', 'rev-base')
-        self.assertRepoAnnotate(duplicate_A, repo, 'file-id', 'rev-A')
-        self.assertRepoAnnotate(duplicate_B, repo, 'file-id', 'rev-B')
-        self.assertRepoAnnotate(duplicate_C, repo, 'file-id', 'rev-C')
-        self.assertRepoAnnotate(duplicate_D, repo, 'file-id', 'rev-D')
-        self.assertRepoAnnotate(duplicate_E, repo, 'file-id', 'rev-E')
+        self.assertRepoAnnotate(duplicate_base, repo, 'file', 'rev-base')
+        self.assertRepoAnnotate(duplicate_A, repo, 'file', 'rev-A')
+        self.assertRepoAnnotate(duplicate_B, repo, 'file', 'rev-B')
+        self.assertRepoAnnotate(duplicate_C, repo, 'file', 'rev-C')
+        self.assertRepoAnnotate(duplicate_D, repo, 'file', 'rev-D')
+        self.assertRepoAnnotate(duplicate_E, repo, 'file', 'rev-E')
 
     def test_annotate_shows_dotted_revnos(self):
         builder = self.create_merged_trees()
@@ -315,7 +315,7 @@
         self.assertBranchAnnotate('1     joe@foo | first\n'
                                   '2     joe@foo | second\n'
                                   '1.1.1 barry@f | third\n',
-                                  builder.get_branch(), 'a-id', 'rev-3')
+                                  builder.get_branch(), 'a', 'rev-3')
 
     def test_annotate_limits_dotted_revnos(self):
         """Annotate should limit dotted revnos to a depth of 12"""
@@ -327,7 +327,7 @@
                                   '1.2.1 jerry@f | fourth\n'
                                   '1.3.1 george@ | fifth\n'
                                   '              | sixth\n',
-                                  builder.get_branch(), 'a-id', 'rev-6',
+                                  builder.get_branch(), 'a', 'rev-6',
                                   verbose=False, full=False)
 
         self.assertBranchAnnotate('1     joe@foo | first\n'
@@ -336,7 +336,7 @@
                                   '1.2.1 jerry@f | fourth\n'
                                   '1.3.1 george@ | fifth\n'
                                   '1.3.1 george@ | sixth\n',
-                                  builder.get_branch(), 'a-id', 'rev-6',
+                                  builder.get_branch(), 'a', 'rev-6',
                                   verbose=False, full=True)
 
         # verbose=True shows everything, the full revno, user id, and date
@@ -346,7 +346,7 @@
                                   '1.2.1 [e-mail]  20061213 | fourth\n'
                                   '1.3.1 [e-mail] 20061213 | fifth\n'
                                   '                              | sixth\n',
-                                  builder.get_branch(), 'a-id', 'rev-6',
+                                  builder.get_branch(), 'a', 'rev-6',
                                   verbose=True, full=False)
 
         self.assertBranchAnnotate('1     [e-mail]    20061213 | first\n'
@@ -355,7 +355,7 @@
                                   '1.2.1 [e-mail]  20061213 | fourth\n'
                                   '1.3.1 [e-mail] 20061213 | fifth\n'
                                   '1.3.1 [e-mail] 20061213 | sixth\n',
-                                  builder.get_branch(), 'a-id', 'rev-6',
+                                  builder.get_branch(), 'a', 'rev-6',
                                   verbose=True, full=True)
 
     def test_annotate_uses_branch_context(self):
@@ -371,7 +371,7 @@
                                   '1.2.1 jerry@f | fourth\n'
                                   '1.3.1 george@ | fifth\n'
                                   '              | sixth\n',
-                                  builder.get_branch(), 'a-id', 'rev-1_3_1',
+                                  builder.get_branch(), 'a', 'rev-1_3_1',
                                   verbose=False, full=False)
 
     def test_annotate_show_ids(self):
@@ -384,7 +384,7 @@
                                   'rev-1_2_1 | fourth\n'
                                   'rev-1_3_1 | fifth\n'
                                   '          | sixth\n',
-                                  builder.get_branch(), 'a-id', 'rev-6',
+                                  builder.get_branch(), 'a', 'rev-6',
                                   show_ids=True, full=False)
 
         self.assertBranchAnnotate('    rev-1 | first\n'
@@ -393,7 +393,7 @@
                                   'rev-1_2_1 | fourth\n'
                                   'rev-1_3_1 | fifth\n'
                                   'rev-1_3_1 | sixth\n',
-                                  builder.get_branch(), 'a-id', 'rev-6',
+                                  builder.get_branch(), 'a', 'rev-6',
                                   show_ids=True, full=True)
 
     def test_annotate_unicode_author(self):
@@ -419,18 +419,18 @@
 
         # this passes if no exception is raised
         to_file = BytesIO()
-        annotate.annotate_file_tree(revtree_1, 'a-id',
+        annotate.annotate_file_tree(revtree_1, 'a',
             to_file=to_file, branch=tree1.branch)
 
         sio = BytesIO()
         to_file = codecs.getwriter('ascii')(sio, 'replace')
-        annotate.annotate_file_tree(revtree_2, 'b-id',
+        annotate.annotate_file_tree(revtree_2, 'b',
             to_file=to_file, branch=tree1.branch)
         self.assertEqualDiff('2   p?rez   | bye\n', sio.getvalue())
 
         # test now with unicode file-like
         to_file = StringIOWithEncoding()
-        annotate.annotate_file_tree(revtree_2, 'b-id',
+        annotate.annotate_file_tree(revtree_2, 'b',
             to_file=to_file, branch=tree1.branch)
         self.assertContainsRe(u'2   p\xe9rez   | bye\n', to_file.getvalue())
 
@@ -454,11 +454,11 @@
         self.addCleanup(tree1.unlock)
 
         self.assertBranchAnnotate('1   committ | hello\n', tree1.branch,
-            'a-id', 'rev-1')
+            'a', 'rev-1')
 
         to_file = BytesIO()
         self.assertBranchAnnotate('2   author@ | bye\n', tree1.branch,
-            'b-id', 'rev-2')
+            'b', 'rev-2')
 
 
 class TestReannotate(tests.TestCase):

=== modified file 'breezy/tests/test_bisect.py'
--- breezy/tests/test_bisect.py	2017-09-26 00:55:04 +0000
+++ breezy/tests/test_bisect.py	2017-11-19 19:02:26 +0000
@@ -115,7 +115,7 @@
         repo = self.tree.branch.repository
         top_revtree = repo.revision_tree(self.tree.last_revision())
         top_revtree.lock_read()
-        top_file = top_revtree.get_file(top_revtree.path2id("test_file"))
+        top_file = top_revtree.get_file("test_file")
         test_content = top_file.read().strip()
         top_file.close()
         top_revtree.unlock()
@@ -126,7 +126,7 @@
         repo = self.tree.branch.repository
         sub_revtree = repo.revision_tree(self.subtree_rev)
         sub_revtree.lock_read()
-        sub_file = sub_revtree.get_file(sub_revtree.path2id("test_file"))
+        sub_file = sub_revtree.get_file("test_file")
         test_content = sub_file.read().strip()
         sub_file.close()
         sub_revtree.unlock()

=== modified file 'breezy/tests/test_branchbuilder.py'
--- breezy/tests/test_branchbuilder.py	2017-11-16 10:35:32 +0000
+++ breezy/tests/test_branchbuilder.py	2017-11-19 19:02:26 +0000
@@ -132,7 +132,7 @@
         self.addCleanup(rev_tree.unlock)
         self.assertTreeShape([(u'', 'a-root-id', 'directory'),
                               (u'a', 'a-id', 'file')], rev_tree)
-        self.assertEqual('contents', rev_tree.get_file_text('a-id'))
+        self.assertEqual('contents', rev_tree.get_file_text('a'))
 
     def test_add_second_file(self):
         builder = self.build_a_rev()
@@ -148,7 +148,7 @@
         self.assertTreeShape([(u'', 'a-root-id', 'directory'),
                               (u'a', 'a-id', 'file'),
                               (u'b', 'b-id', 'file')], rev_tree)
-        self.assertEqual('content_b', rev_tree.get_file_text('b-id'))
+        self.assertEqual('content_b', rev_tree.get_file_text('b'))
 
     def test_add_empty_dir(self):
         builder = self.build_a_rev()
@@ -207,7 +207,8 @@
         rev_tree = branch.repository.revision_tree(rev_id2)
         rev_tree.lock_read()
         self.addCleanup(rev_tree.unlock)
-        self.assertEqual('new\ncontent\n', rev_tree.get_file_text('a-id'))
+        self.assertEqual('new\ncontent\n',
+                         rev_tree.get_file_text(rev_tree.id2path('a-id')))
 
     def test_delete_file(self):
         builder = self.build_a_rev()
@@ -304,7 +305,7 @@
         self.assertTreeShape([(u'', 'a-root-id', 'directory'),
                               (u'a', 'a-id', 'file'),
                              ], b_tree)
-        self.assertEqual('new\ncontent\n', b_tree.get_file_text('a-id'))
+        self.assertEqual('new\ncontent\n', b_tree.get_file_text('a'))
 
         # We should still be using the content from A in C, not from B
         c_tree = repo.revision_tree('C-id')
@@ -312,8 +313,8 @@
                               (u'a', 'a-id', 'file'),
                               (u'c', 'c-id', 'file'),
                              ], c_tree)
-        self.assertEqual('contents', c_tree.get_file_text('a-id'))
-        self.assertEqual('alt\ncontent\n', c_tree.get_file_text('c-id'))
+        self.assertEqual('contents', c_tree.get_file_text('a'))
+        self.assertEqual('alt\ncontent\n', c_tree.get_file_text('c'))
 
     def test_set_merge_parent(self):
         builder = self.build_a_rev()
@@ -363,7 +364,7 @@
                              ], d_tree)
         # Because we copied the exact text into *this* tree, the 'c' file
         # should look like it was not modified in the merge
-        self.assertEqual('C-id', d_tree.get_file_revision('c-id'))
+        self.assertEqual('C-id', d_tree.get_file_revision('c'))
 
     def test_set_parent_to_null(self):
         builder = self.build_a_rev()

=== modified file 'breezy/tests/test_bundle.py'
--- breezy/tests/test_bundle.py	2017-11-16 00:39:04 +0000
+++ breezy/tests/test_bundle.py	2017-11-19 19:02:26 +0000
@@ -90,7 +90,7 @@
     def all_file_ids(self):
         return set(self.paths.keys())
 
-    def is_executable(self, file_id):
+    def is_executable(self, path, file_id):
         # Not all the files are executable.
         return False
 
@@ -110,7 +110,9 @@
         for path, file_id in self.ids.items():
             yield path, self[file_id]
 
-    def kind(self, file_id):
+    def kind(self, path, file_id=None):
+        if file_id is None:
+            file_id = self.path2id(path)
         if file_id in self.contents:
             kind = 'file'
         else:
@@ -121,9 +123,9 @@
         from ..bzr.inventory import (InventoryFile, InventoryDirectory,
             InventoryLink)
         name = os.path.basename(path)
-        kind = self.kind(file_id)
+        kind = self.kind(path, file_id)
         parent_id = self.parent_id(file_id)
-        text_sha_1, text_size = self.contents_stats(file_id)
+        text_sha_1, text_size = self.contents_stats(path, file_id)
         if kind == 'directory':
             ie = InventoryDirectory(file_id, name, parent_id)
         elif kind == 'file':
@@ -153,25 +155,36 @@
     def has_id(self, file_id):
         return self.id2path(file_id) is not None
 
-    def get_file(self, file_id):
+    def get_file(self, path, file_id=None):
+        if file_id is None:
+            file_id = self.path2id(path)
         result = BytesIO()
-        result.write(self.contents[file_id])
+        try:
+            result.write(self.contents[file_id])
+        except KeyError:
+            raise errors.NoSuchFile(path)
         result.seek(0, 0)
         return result
 
-    def get_file_revision(self, file_id):
+    def get_file_revision(self, path, file_id=None):
+        if file_id is None:
+            file_id = self.path2id(path)
         return self.inventory[file_id].revision
 
-    def get_file_size(self, file_id):
+    def get_file_size(self, path, file_id=None):
+        if file_id is None:
+            file_id = self.path2id(path)
         return self.inventory[file_id].text_size
 
-    def get_file_sha1(self, file_id):
+    def get_file_sha1(self, path, file_id=None):
+        if file_id is None:
+            file_id = self.path2id(path)
         return self.inventory[file_id].text_sha1
 
-    def contents_stats(self, file_id):
+    def contents_stats(self, path, file_id):
         if file_id not in self.contents:
             return None, None
-        text_sha1 = osutils.sha_file(self.get_file(file_id))
+        text_sha1 = osutils.sha_file(self.get_file(path, file_id))
         return text_sha1, len(self.contents[file_id])
 
 
@@ -284,8 +297,10 @@
     def adds_test(self, btree):
         self.assertEqual(btree.id2path("e"), "grandparent/parent/file")
         self.assertEqual(btree.path2id("grandparent/parent/file"), "e")
-        self.assertEqual(btree.get_file("e").read(), "Extra cheese\n")
-        self.assertEqual(btree.get_symlink_target('f'), 'venus')
+        self.assertEqual(btree.get_file("grandparent/parent/file").read(),
+                         "Extra cheese\n")
+        self.assertEqual(
+            btree.get_symlink_target('grandparent/parent/symlink'), 'venus')
 
     def test_adds2(self):
         """File/inventory adds, with patch-compatibile renames"""
@@ -307,8 +322,8 @@
         return btree
 
     def get_file_test(self, btree):
-        self.assertEqual(btree.get_file("e").read(), "Lemon\n")
-        self.assertEqual(btree.get_file("c").read(), "Hello\n")
+        self.assertEqual(btree.get_file(btree.id2path("e")).read(), "Lemon\n")
+        self.assertEqual(btree.get_file(btree.id2path("c")).read(), "Hello\n")
 
     def test_get_file(self):
         """Get file contents"""
@@ -318,7 +333,7 @@
         self.get_file_test(btree)
 
     def test_get_file2(self):
-        """Get file contents, with patch-compatibile renames"""
+        """Get file contents, with patch-compatible renames"""
         btree = self.make_tree_3()
         btree.contents_by_id = False
         mod_patch = self.unified_diff([], ["Lemon\n"])
@@ -330,7 +345,7 @@
     def test_delete(self):
         "Deletion by bundle"
         btree = self.make_tree_1()[0]
-        self.assertEqual(btree.get_file("c").read(), "Hello\n")
+        self.assertEqual(btree.get_file(btree.id2path("c")).read(), "Hello\n")
         btree.note_deletion("grandparent/parent/file")
         self.assertTrue(btree.id2path("c") is None)
         self.assertTrue(btree.path2id("grandparent/parent/file") is None)
@@ -516,13 +531,14 @@
                 # Now check that the file contents are all correct
                 for inventory_id in old.all_file_ids():
                     try:
-                        old_file = old.get_file(inventory_id)
+                        old_file = old.get_file(old.id2path(inventory_id))
                     except errors.NoSuchFile:
                         continue
                     if old_file is None:
                         continue
-                    self.assertEqual(old_file.read(),
-                                     new.get_file(inventory_id).read())
+                    self.assertEqual(
+                            old_file.read(),
+                            new.get_file(new.id2path(inventory_id)).read())
             finally:
                 new.unlock()
                 old.unlock()
@@ -582,10 +598,10 @@
 
         for path, status, kind, fileid, entry in base_files:
             # Check that the meta information is the same
-            self.assertEqual(base_tree.get_file_size(fileid),
-                    to_tree.get_file_size(fileid))
-            self.assertEqual(base_tree.get_file_sha1(fileid),
-                    to_tree.get_file_sha1(fileid))
+            self.assertEqual(base_tree.get_file_size(path, fileid),
+                    to_tree.get_file_size(to_tree.id2path(fileid)))
+            self.assertEqual(base_tree.get_file_sha1(path, fileid),
+                    to_tree.get_file_sha1(to_tree.id2path(fileid)))
             # Check that the contents are the same
             # This is pretty expensive
             # self.assertEqual(base_tree.get_file(fileid).read(),
@@ -712,7 +728,7 @@
         if getattr(bundle, 'revision_tree', None) is not None:
             # Not all bundle formats supports revision_tree
             bund_tree = bundle.revision_tree(self.b1.repository, 'l@cset-0-1')
-            self.assertEqual(link_target, bund_tree.get_symlink_target(link_id))
+            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)
@@ -726,7 +742,7 @@
             # Not all bundle formats supports revision_tree
             bund_tree = bundle.revision_tree(self.b1.repository, 'l@cset-0-2')
             self.assertEqual(new_link_target,
-                             bund_tree.get_symlink_target(link_id))
+                             bund_tree.get_symlink_target('link2'))
 
         tt = TreeTransform(self.tree1)
         trans_id = tt.trans_id_tree_file_id(link_id)
@@ -965,7 +981,7 @@
         self.tree1.commit('message', rev_id='revid1')
         bundle = self.get_valid_bundle('null:', 'revid1')
         tree = self.get_bundle_tree(bundle, 'revid1')
-        root_revision = tree.get_file_revision(tree.get_root_id())
+        root_revision = tree.get_file_revision(u'', tree.get_root_id())
         self.assertEqual('revid1', root_revision)
 
     def test_install_revisions(self):

=== modified file 'breezy/tests/test_bzrdir.py'
--- breezy/tests/test_bzrdir.py	2017-10-27 00:18:42 +0000
+++ breezy/tests/test_bzrdir.py	2017-11-19 19:02:26 +0000
@@ -840,7 +840,9 @@
         tree2.lock_read()
         self.addCleanup(tree2.unlock)
         self.assertPathExists('tree2/subtree/file')
-        self.assertEqual('tree-reference', tree2.kind('subtree-root'))
+        self.assertEqual(
+                'tree-reference',
+                tree2.kind('subtree', 'subtree-root'))
 
     def test_cloning_metadir(self):
         """Ensure that cloning metadir is suitable"""

=== modified file 'breezy/tests/test_commit.py'
--- breezy/tests/test_commit.py	2017-11-12 18:17:03 +0000
+++ breezy/tests/test_commit.py	2017-11-19 19:02:26 +0000
@@ -101,13 +101,13 @@
 
         tree1 = b.repository.revision_tree(rev1)
         tree1.lock_read()
-        text = tree1.get_file_text(file_id)
+        text = tree1.get_file_text('hello')
         tree1.unlock()
         self.assertEqual('hello world', text)
 
         tree2 = b.repository.revision_tree(rev2)
         tree2.lock_read()
-        text = tree2.get_file_text(file_id)
+        text = tree2.get_file_text('hello')
         tree2.unlock()
         self.assertEqual('version 2', text)
 
@@ -243,14 +243,14 @@
         tree2.lock_read()
         self.addCleanup(tree2.unlock)
         self.assertTrue(tree2.has_filename('hello'))
-        self.assertEqual(tree2.get_file_text('hello-id'), 'hello')
-        self.assertEqual(tree2.get_file_text('buongia-id'), 'new text')
+        self.assertEqual(tree2.get_file_text('hello'), 'hello')
+        self.assertEqual(tree2.get_file_text('buongia'), 'new text')
 
         tree3 = b.repository.revision_tree('test@rev-3')
         tree3.lock_read()
         self.addCleanup(tree3.unlock)
         self.assertFalse(tree3.has_filename('hello'))
-        self.assertEqual(tree3.get_file_text('buongia-id'), 'new text')
+        self.assertEqual(tree3.get_file_text('buongia'), 'new text')
 
     def test_commit_rename(self):
         """Test commit of a revision where a file is renamed."""
@@ -268,18 +268,18 @@
         tree1.lock_read()
         self.addCleanup(tree1.unlock)
         eq(tree1.id2path('hello-id'), 'hello')
-        eq(tree1.get_file_text('hello-id'), 'contents of hello\n')
+        eq(tree1.get_file_text('hello'), 'contents of hello\n')
         self.assertFalse(tree1.has_filename('fruity'))
         self.check_tree_shape(tree1, ['hello'])
-        eq(tree1.get_file_revision('hello-id'), 'test@rev-1')
+        eq(tree1.get_file_revision('hello'), 'test@rev-1')
 
         tree2 = b.repository.revision_tree('test@rev-2')
         tree2.lock_read()
         self.addCleanup(tree2.unlock)
         eq(tree2.id2path('hello-id'), 'fruity')
-        eq(tree2.get_file_text('hello-id'), 'contents of hello\n')
+        eq(tree2.get_file_text('fruity'), 'contents of hello\n')
         self.check_tree_shape(tree2, ['fruity'])
-        eq(tree2.get_file_revision('hello-id'), 'test@rev-2')
+        eq(tree2.get_file_revision('fruity'), 'test@rev-2')
 
     def test_reused_rev_id(self):
         """Test that a revision id cannot be reused in a branch"""
@@ -646,11 +646,11 @@
         timestamp_1ms = round(timestamp, 3)
         self.assertEqual(timestamp_1ms, timestamp)
 
-    def assertBasisTreeKind(self, kind, tree, file_id):
+    def assertBasisTreeKind(self, kind, tree, path):
         basis = tree.basis_tree()
         basis.lock_read()
         try:
-            self.assertEqual(kind, basis.kind(file_id))
+            self.assertEqual(kind, basis.kind(path))
         finally:
             basis.unlock()
 
@@ -660,43 +660,43 @@
         os.symlink('target', 'name')
         tree.add('name', 'a-file-id')
         tree.commit('Added a symlink')
-        self.assertBasisTreeKind('symlink', tree, 'a-file-id')
+        self.assertBasisTreeKind('symlink', tree, 'name')
 
         os.unlink('name')
         self.build_tree(['name'])
         tree.commit('Changed symlink to file')
-        self.assertBasisTreeKind('file', tree, 'a-file-id')
+        self.assertBasisTreeKind('file', tree, 'name')
 
         os.unlink('name')
         os.symlink('target', 'name')
         tree.commit('file to symlink')
-        self.assertBasisTreeKind('symlink', tree, 'a-file-id')
+        self.assertBasisTreeKind('symlink', tree, 'name')
 
         os.unlink('name')
         os.mkdir('name')
         tree.commit('symlink to directory')
-        self.assertBasisTreeKind('directory', tree, 'a-file-id')
+        self.assertBasisTreeKind('directory', tree, 'name')
 
         os.rmdir('name')
         os.symlink('target', 'name')
         tree.commit('directory to symlink')
-        self.assertBasisTreeKind('symlink', tree, 'a-file-id')
+        self.assertBasisTreeKind('symlink', tree, 'name')
 
         # prepare for directory <-> file tests
         os.unlink('name')
         os.mkdir('name')
         tree.commit('symlink to directory')
-        self.assertBasisTreeKind('directory', tree, 'a-file-id')
+        self.assertBasisTreeKind('directory', tree, 'name')
 
         os.rmdir('name')
         self.build_tree(['name'])
         tree.commit('Changed directory to file')
-        self.assertBasisTreeKind('file', tree, 'a-file-id')
+        self.assertBasisTreeKind('file', tree, 'name')
 
         os.unlink('name')
         os.mkdir('name')
         tree.commit('file to directory')
-        self.assertBasisTreeKind('directory', tree, 'a-file-id')
+        self.assertBasisTreeKind('directory', tree, 'name')
 
     def test_commit_unversioned_specified(self):
         """Commit should raise if specified files isn't in basis or worktree"""

=== modified file 'breezy/tests/test_commit_merge.py'
--- breezy/tests/test_commit_merge.py	2017-07-30 23:53:38 +0000
+++ breezy/tests/test_commit_merge.py	2017-11-19 19:02:26 +0000
@@ -98,8 +98,8 @@
 
         wty.commit('merge from x', rev_id='y@u-0-2', allow_pointless=False)
         tree = by.repository.revision_tree('y@u-0-2')
-        self.assertEqual(tree.get_file_revision('ecks-id'), 'x@u-0-1')
-        self.assertEqual(tree.get_file_revision('why-id'), 'y@u-0-1')
+        self.assertEqual(tree.get_file_revision('ecks'), 'x@u-0-1')
+        self.assertEqual(tree.get_file_revision('why'), 'y@u-0-1')
 
         check.check_dwim(bx.base, False, True, True)
         check.check_dwim(by.base, False, True, True)

=== modified file 'breezy/tests/test_diff.py'
--- breezy/tests/test_diff.py	2017-11-12 13:53:51 +0000
+++ breezy/tests/test_diff.py	2017-11-19 19:02:26 +0000
@@ -700,10 +700,9 @@
 
     def diff(self, file_id, old_path, new_path, old_kind, new_kind):
         self.to_file.write('was: ')
-        self.to_file.write(self.old_tree.get_file(file_id).read())
+        self.to_file.write(self.old_tree.get_file(old_path).read())
         self.to_file.write('is: ')
-        self.to_file.write(self.new_tree.get_file(file_id).read())
-        pass
+        self.to_file.write(self.new_tree.get_file(new_path).read())
 
 
 class TestDiffTree(tests.TestCaseWithTransport):
@@ -728,17 +727,20 @@
         self.new_tree.add('newdir')
         self.new_tree.add('newdir/newfile', 'file-id')
         differ = diff.DiffText(self.old_tree, self.new_tree, BytesIO())
-        differ.diff_text('file-id', None, 'old label', 'new label')
+        differ.diff_text('olddir/oldfile', None, 'old label',
+                         'new label', 'file-id', None)
         self.assertEqual(
             '--- old label\n+++ new label\n@@ -1,1 +0,0 @@\n-old\n\n',
             differ.to_file.getvalue())
         differ.to_file.seek(0)
-        differ.diff_text(None, 'file-id', 'old label', 'new label')
+        differ.diff_text(None, 'newdir/newfile',
+                         'old label', 'new label', None, 'file-id')
         self.assertEqual(
             '--- old label\n+++ new label\n@@ -0,0 +1,1 @@\n+new\n\n',
             differ.to_file.getvalue())
         differ.to_file.seek(0)
-        differ.diff_text('file-id', 'file-id', 'old label', 'new label')
+        differ.diff_text('olddir/oldfile', 'newdir/newfile',
+                         'old label', 'new label', 'file-id', 'file-id')
         self.assertEqual(
             '--- old label\n+++ new label\n@@ -1,1 +1,1 @@\n-old\n+new\n\n',
             differ.to_file.getvalue())
@@ -1454,7 +1456,7 @@
         diff_obj = diff.DiffFromTool(['python', '-c',
                                       'print "@old_path @new_path"'],
                                      basis_tree, tree, output)
-        diff_obj._prepare_files('file-id', 'file', 'file')
+        diff_obj._prepare_files('file', 'file', file_id='file-id')
         # The old content should be readonly
         self.assertReadableByAttrib(diff_obj._root, 'old\\file',
                                     r'R.*old\\file$')
@@ -1492,8 +1494,8 @@
                                      old_tree, tree, output)
         self.addCleanup(diff_obj.finish)
         self.assertContainsRe(diff_obj._root, 'brz-diff-[^/]*')
-        old_path, new_path = diff_obj._prepare_files('file-id', 'oldname',
-                                                     'newname')
+        old_path, new_path = diff_obj._prepare_files(
+                'oldname', 'newname', file_id='file-id')
         self.assertContainsRe(old_path, 'old/oldname$')
         self.assertEqual(315532800, os.stat(old_path).st_mtime)
         self.assertContainsRe(new_path, 'tree/newname$')
@@ -1502,7 +1504,7 @@
         if osutils.host_os_dereferences_symlinks():
             self.assertTrue(os.path.samefile('tree/newname', new_path))
         # make sure we can create files with the same parent directories
-        diff_obj._prepare_files('file2-id', 'oldname2', 'newname2')
+        diff_obj._prepare_files('oldname2', 'newname2', file_id='file2-id')
 
 
 class TestDiffFromToolEncodedFilename(tests.TestCaseWithTransport):

=== modified file 'breezy/tests/test_dirstate.py'
--- breezy/tests/test_dirstate.py	2017-11-12 13:53:51 +0000
+++ breezy/tests/test_dirstate.py	2017-11-19 19:02:26 +0000
@@ -315,7 +315,7 @@
         tree, state, expected = self.create_basic_dirstate()
         # Now we will just remove and add every file so we get an extra entry
         # per entry. Unversion in reverse order so we handle subdirs
-        tree.unversion(['f-id', 'b-c-id', 'e-id', 'd-id', 'c-id', 'b-id', 'a-id'])
+        tree.unversion(['f', 'b-c', 'b/d/e', 'b/d', 'b/c', 'b', 'a'])
         tree.add(['a', 'b', 'b/c', 'b/d', 'b/d/e', 'b-c', 'f'],
                  ['a-id2', 'b-id2', 'c-id2', 'd-id2', 'e-id2', 'b-c-id2', 'f-id2'])
 
@@ -1105,7 +1105,7 @@
         try:
             tree1.add('')
             tree1.add(['a file'], ['file-id'], ['file'])
-            tree1.put_file_bytes_non_atomic('file-id', 'file-content')
+            tree1.put_file_bytes_non_atomic('a file', 'file-content')
             revid1 = tree1.commit('foo')
         finally:
             tree1.unlock()
@@ -1113,7 +1113,7 @@
         tree2 = memorytree.MemoryTree.create_on_branch(branch2)
         tree2.lock_write()
         try:
-            tree2.put_file_bytes_non_atomic('file-id', 'new file-content')
+            tree2.put_file_bytes_non_atomic('a file', 'new file-content')
             revid2 = tree2.commit('foo')
             root_id = tree2.get_root_id()
         finally:

=== modified file 'breezy/tests/test_fetch.py'
--- breezy/tests/test_fetch.py	2017-11-16 00:39:04 +0000
+++ breezy/tests/test_fetch.py	2017-11-19 19:02:26 +0000
@@ -251,7 +251,7 @@
                              ('2-2', 'agreement\n')]:
             self.assertEqualDiff(
                 br2.repository.revision_tree(
-                    rev_id).get_file_text('this-file-id'), text)
+                    rev_id).get_file_text('file'), text)
 
 
 class TestKnitToPackFetch(TestCaseWithTransport):

=== modified file 'breezy/tests/test_filter_tree.py'
--- breezy/tests/test_filter_tree.py	2017-05-22 00:56:52 +0000
+++ breezy/tests/test_filter_tree.py	2017-11-19 19:02:26 +0000
@@ -44,10 +44,10 @@
     def test_get_file_text(self):
         self.make_tree()
         self.assertEqual(
-            self.underlying_tree.get_file_text('hello-id'),
+            self.underlying_tree.get_file_text('hello'),
             'hello world')
         self.assertEqual(
-            self.filter_tree.get_file_text('hello-id'),
+            self.filter_tree.get_file_text('hello'),
             'HELLO WORLD')
 
     def test_tar_export_content_filter_tree(self):

=== modified file 'breezy/tests/test_foreign.py'
--- breezy/tests/test_foreign.py	2017-11-12 13:53:51 +0000
+++ breezy/tests/test_foreign.py	2017-11-19 19:02:26 +0000
@@ -193,8 +193,8 @@
             for revid in todo:
                 rev = self.source.repository.get_revision(revid)
                 tree = self.source.repository.revision_tree(revid)
-                def get_file_with_stat(file_id, path=None):
-                    return (tree.get_file(file_id), None)
+                def get_file_with_stat(path, file_id=None):
+                    return (tree.get_file(path, file_id), None)
                 tree.get_file_with_stat = get_file_with_stat
                 new_revid = self.target.mapping.revision_id_foreign_to_bzr(
                     (str(rev.timestamp), str(rev.timezone),
@@ -423,7 +423,7 @@
         wt.commit('bla-a')
         root_id = wt.get_root_id()
         target = wt.controldir.sprout('br2').open_workingtree()
-        target.unversion(['bla-a'])
+        target.unversion(['bla'])
         target.add('bla', 'bla-b')
         target.commit('bla-b')
         target_basis = target.basis_tree()

=== modified file 'breezy/tests/test_memorytree.py'
--- breezy/tests/test_memorytree.py	2017-06-10 00:17:06 +0000
+++ breezy/tests/test_memorytree.py	2017-11-19 19:02:26 +0000
@@ -49,7 +49,7 @@
         tree.lock_read()
         self.assertEqual([rev_id], tree.get_parent_ids())
         self.assertEqual('contents of foo\n',
-            tree.get_file(tree.path2id('foo')).read())
+            tree.get_file('foo').read())
         tree.unlock()
 
     def test_get_root_id(self):
@@ -110,8 +110,8 @@
         tree.lock_write()
         tree.add(['', 'foo'], ids=['root-id', 'foo-id'],
                   kinds=['directory', 'file'])
-        tree.put_file_bytes_non_atomic('foo-id', 'barshoom')
-        self.assertEqual('barshoom', tree.get_file('foo-id').read())
+        tree.put_file_bytes_non_atomic('foo', 'barshoom')
+        self.assertEqual('barshoom', tree.get_file('foo').read())
         tree.unlock()
 
     def test_put_existing_file(self):
@@ -120,9 +120,9 @@
         tree.lock_write()
         tree.add(['', 'foo'], ids=['root-id', 'foo-id'],
                  kinds=['directory', 'file'])
-        tree.put_file_bytes_non_atomic('foo-id', 'first-content')
-        tree.put_file_bytes_non_atomic('foo-id', 'barshoom')
-        self.assertEqual('barshoom', tree.get_file('foo-id').read())
+        tree.put_file_bytes_non_atomic('foo', 'first-content')
+        tree.put_file_bytes_non_atomic('foo', 'barshoom')
+        self.assertEqual('barshoom', tree.get_file('foo').read())
         tree.unlock()
 
     def test_add_in_subdir(self):
@@ -139,7 +139,7 @@
         tree.add(['adir/afile'], ['file-id'], ['file'])
         self.assertEqual('adir/afile', tree.id2path('file-id'))
         self.assertEqual('adir', tree.id2path('dir-id'))
-        tree.put_file_bytes_non_atomic('file-id', 'barshoom')
+        tree.put_file_bytes_non_atomic('adir/afile', 'barshoom')