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

[Jelmer Vernooij]

Use contextlib.ExitStack rather than our homegrown OperationWithCleanups.

Use contextlib.ExitStack rather than our homegrown OperationWithCleanups.

The former is available by default in Python 3.3, and I've imported a
copy in breezy.cleanups for Python 2.

ExitStack is somewhat easier to use when dealing with contexts, which I need
for subtrees.

[Martin Packman (gz)]

Okay, I'm sold on this being a better spelling. See inline notes to fix, conflict and copyright statements for adopted code from upstream.

review: Approve

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

Merging failed
https://ci.breezy-vcs.org/job/brz/job/brz-land/449/

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

Merging failed
https://ci.breezy-vcs.org/job/brz/job/brz-land/453/

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

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

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

Merging failed
https://ci.breezy-vcs.org/job/brz/job/brz-land/470/

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

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

=== modified file 'breezy/branch.py'
--- breezy/branch.py	2019-06-22 18:46:21 +0000
+++ breezy/branch.py	2019-07-27 23:18:50 +0000
@@ -20,6 +20,7 @@
 lazy_import(globals(), """
 import itertools
 from breezy import (
+    cleanup,
     config as _mod_config,
     debug,
     memorytree,
@@ -2230,7 +2231,8 @@
             is being called because it's the master of the primary branch,
             so it should not run its hooks.
         """
-        with self.target.lock_write():
+        with cleanup.ExitStack() as exit_stack:
+            exit_stack.enter_context(self.target.lock_write())
             bound_location = self.target.get_bound_location()
             if local and not bound_location:
                 raise errors.LocalRequiresBoundBranch()
@@ -2249,20 +2251,16 @@
                 # not pulling from master, so we need to update master.
                 master_branch = self.target.get_master_branch(
                     possible_transports)
-                master_branch.lock_write()
-            try:
-                if master_branch:
-                    # pull from source into master.
-                    master_branch.pull(
-                        self.source, overwrite, stop_revision, run_hooks=False)
-                return self._pull(
-                    overwrite, stop_revision, _hook_master=master_branch,
-                    run_hooks=run_hooks,
-                    _override_hook_target=_override_hook_target,
-                    merge_tags_to_master=not source_is_master)
-            finally:
-                if master_branch:
-                    master_branch.unlock()
+                exit_stack.enter_context(master_branch.lock_write())
+            if master_branch:
+                # pull from source into master.
+                master_branch.pull(
+                    self.source, overwrite, stop_revision, run_hooks=False)
+            return self._pull(
+                overwrite, stop_revision, _hook_master=master_branch,
+                run_hooks=run_hooks,
+                _override_hook_target=_override_hook_target,
+                merge_tags_to_master=not source_is_master)
 
     def push(self, overwrite=False, stop_revision=None, lossy=False,
              _override_hook_source_branch=None):

=== modified file 'breezy/builtins.py'
--- breezy/builtins.py	2019-07-25 22:37:25 +0000
+++ breezy/builtins.py	2019-07-27 23:18:50 +0000
@@ -552,7 +552,7 @@
 
     def run(self, revision=None, directory='.', force=False):
         tree, _ = WorkingTree.open_containing(directory)
-        self.add_cleanup(tree.lock_tree_write().unlock)
+        self.enter_context(tree.lock_tree_write())
         if not force:
             try:
                 tree.check_state()
@@ -602,14 +602,14 @@
         if tree:
             try:
                 wt = WorkingTree.open_containing(location)[0]
-                self.add_cleanup(wt.lock_read().unlock)
+                self.enter_context(wt.lock_read())
             except (errors.NoWorkingTree, errors.NotLocalUrl):
                 raise errors.NoWorkingTree(location)
             b = wt.branch
             revid = wt.last_revision()
         else:
             b = Branch.open_containing(location)[0]
-            self.add_cleanup(b.lock_read().unlock)
+            self.enter_context(b.lock_read())
             if revision:
                 if len(revision) != 1:
                     raise errors.BzrCommandError(gettext(
@@ -646,11 +646,11 @@
         try:
             wt = WorkingTree.open_containing(directory)[0]
             b = wt.branch
-            self.add_cleanup(wt.lock_read().unlock)
+            self.enter_context(wt.lock_read())
         except (errors.NoWorkingTree, errors.NotLocalUrl):
             wt = None
             b = Branch.open_containing(directory)[0]
-            self.add_cleanup(b.lock_read().unlock)
+            self.enter_context(b.lock_read())
         revision_ids = []
         if revision is not None:
             revision_ids.extend(rev.as_revision_id(b) for rev in revision)
@@ -766,7 +766,7 @@
                 to_file=self.outf, should_print=(not is_quiet()))
 
         if base_tree:
-            self.add_cleanup(base_tree.lock_read().unlock)
+            self.enter_context(base_tree.lock_read())
         tree, file_list = tree_files_for_add(file_list)
         added, ignored = tree.smart_add(
             file_list, not no_recurse, action=action, save=not dry_run)
@@ -875,17 +875,17 @@
 
         revision = _get_one_revision('inventory', revision)
         work_tree, file_list = WorkingTree.open_containing_paths(file_list)
-        self.add_cleanup(work_tree.lock_read().unlock)
+        self.enter_context(work_tree.lock_read())
         if revision is not None:
             tree = revision.as_tree(work_tree.branch)
 
             extra_trees = [work_tree]
-            self.add_cleanup(tree.lock_read().unlock)
+            self.enter_context(tree.lock_read())
         else:
             tree = work_tree
             extra_trees = []
 
-        self.add_cleanup(tree.lock_read().unlock)
+        self.enter_context(tree.lock_read())
         if file_list is not None:
             paths = tree.find_related_paths_across_trees(
                 file_list, extra_trees, require_versioned=True)
@@ -940,7 +940,7 @@
             if file_name == '':
                 raise errors.BzrCommandError(
                     gettext("can not copy root of branch"))
-        self.add_cleanup(tree.lock_tree_write().unlock)
+        self.enter_context(tree.lock_tree_write())
         into_existing = osutils.isdir(names_list[-1])
         if not into_existing:
             try:
@@ -1033,7 +1033,7 @@
             if file_name == '':
                 raise errors.BzrCommandError(
                     gettext("can not move root of branch"))
-        self.add_cleanup(tree.lock_tree_write().unlock)
+        self.enter_context(tree.lock_tree_write())
         self._run(tree, names_list, rel_names, after)
 
     def run_auto(self, names_list, after, dry_run):
@@ -1045,7 +1045,7 @@
                 gettext('--after cannot be specified with --auto.'))
         work_tree, file_list = WorkingTree.open_containing_paths(
             names_list, default_directory='.')
-        self.add_cleanup(work_tree.lock_tree_write().unlock)
+        self.enter_context(work_tree.lock_tree_write())
         rename_map.RenameMap.guess_renames(
             work_tree.basis_tree(), work_tree, dry_run)
 
@@ -1199,11 +1199,11 @@
         try:
             tree_to = WorkingTree.open_containing(directory)[0]
             branch_to = tree_to.branch
-            self.add_cleanup(tree_to.lock_write().unlock)
+            self.enter_context(tree_to.lock_write())
         except errors.NoWorkingTree:
             tree_to = None
             branch_to = Branch.open_containing(directory)[0]
-            self.add_cleanup(branch_to.lock_write().unlock)
+            self.enter_context(branch_to.lock_write())
             if show_base:
                 warning(gettext("No working tree, ignoring --show-base"))
 
@@ -1243,7 +1243,7 @@
         else:
             branch_from = Branch.open(location,
                                       possible_transports=possible_transports)
-            self.add_cleanup(branch_from.lock_read().unlock)
+            self.enter_context(branch_from.lock_read())
             # Remembers if asked explicitly or no previous location is set
             if (remember
                     or (remember is None and branch_to.get_parent() is None)):
@@ -1475,7 +1475,7 @@
         if files_from is not None and files_from != from_location:
             accelerator_tree = WorkingTree.open(files_from)
         revision = _get_one_revision('branch', revision)
-        self.add_cleanup(br_from.lock_read().unlock)
+        self.enter_context(br_from.lock_read())
         if revision is not None:
             revision_id = revision.as_revision_id(br_from)
         else:
@@ -1699,9 +1699,9 @@
     @display_command
     def run(self, dir=u'.'):
         tree = WorkingTree.open_containing(dir)[0]
-        self.add_cleanup(tree.lock_read().unlock)
+        self.enter_context(tree.lock_read())
         old_tree = tree.basis_tree()
-        self.add_cleanup(old_tree.lock_read().unlock)
+        self.enter_context(old_tree.lock_read())
         renames = []
         iterator = tree.iter_changes(old_tree, include_unchanged=True)
         for change in iterator:
@@ -1772,11 +1772,10 @@
             possible_transports=possible_transports)
         if master is not None:
             branch_location = master.base
-            tree.lock_write()
+            self.enter_context(tree.lock_write())
         else:
             branch_location = tree.branch.base
-            tree.lock_tree_write()
-        self.add_cleanup(tree.unlock)
+            self.enter_context(tree.lock_tree_write())
         # get rid of the final '/' and be ready for display
         branch_location = urlutils.unescape_for_display(
             branch_location.rstrip('/'),
@@ -1904,7 +1903,7 @@
         if file_list is not None:
             file_list = [f for f in file_list]
 
-        self.add_cleanup(tree.lock_write().unlock)
+        self.enter_context(tree.lock_write())
         # Heuristics should probably all move into tree.remove_smart or
         # some such?
         if new:
@@ -1973,7 +1972,7 @@
     @display_command
     def run(self, location="."):
         branch = Branch.open_containing(location)[0]
-        self.add_cleanup(branch.lock_read().unlock)
+        self.enter_context(branch.lock_read())
         graph = branch.repository.get_graph()
         history = list(graph.iter_lefthand_ancestry(branch.last_revision(),
                                                     [_mod_revision.NULL_REVISION]))
@@ -2001,7 +2000,7 @@
             b = wt.branch
             last_revision = wt.last_revision()
 
-        self.add_cleanup(b.repository.lock_read().unlock)
+        self.enter_context(b.repository.lock_read())
         graph = b.repository.get_graph()
         revisions = [revid for revid, parents in
                      graph.iter_ancestry([last_revision])]
@@ -2356,7 +2355,7 @@
         (old_tree, new_tree,
          old_branch, new_branch,
          specific_files, extra_trees) = get_trees_and_branches_to_diff_locked(
-            file_list, revision, old, new, self.add_cleanup, apply_view=True)
+            file_list, revision, old, new, self._exit_stack, apply_view=True)
         # GNU diff on Windows uses ANSI encoding for filenames
         path_encoding = osutils.get_diff_header_encoding()
         return show_diff_trees(old_tree, new_tree, self.outf,
@@ -2384,9 +2383,9 @@
     @display_command
     def run(self, show_ids=False, directory=u'.'):
         tree = WorkingTree.open_containing(directory)[0]
-        self.add_cleanup(tree.lock_read().unlock)
+        self.enter_context(tree.lock_read())
         old = tree.basis_tree()
-        self.add_cleanup(old.lock_read().unlock)
+        self.enter_context(old.lock_read())
         for path, ie in old.iter_entries_by_dir():
             if not tree.has_id(ie.file_id):
                 self.outf.write(path)
@@ -2407,7 +2406,7 @@
     @display_command
     def run(self, null=False, directory=u'.'):
         tree = WorkingTree.open_containing(directory)[0]
-        self.add_cleanup(tree.lock_read().unlock)
+        self.enter_context(tree.lock_read())
         td = tree.changes_from(tree.basis_tree())
         self.cleanup_now()
         for path, id, kind, text_modified, meta_modified in td.modified:
@@ -2428,9 +2427,9 @@
     @display_command
     def run(self, null=False, directory=u'.'):
         wt = WorkingTree.open_containing(directory)[0]
-        self.add_cleanup(wt.lock_read().unlock)
+        self.enter_context(wt.lock_read())
         basis = wt.basis_tree()
-        self.add_cleanup(basis.lock_read().unlock)
+        self.enter_context(basis.lock_read())
         for path in wt.all_versioned_paths():
             if basis.has_filename(path):
                 continue
@@ -2764,7 +2763,7 @@
         if file_list:
             # find the file ids to log and check for directory filtering
             b, file_info_list, rev1, rev2 = _get_info_for_log_files(
-                revision, file_list, self.add_cleanup)
+                revision, file_list, self._exit_stack)
             for relpath, file_id, kind in file_info_list:
                 if file_id is None:
                     raise errors.BzrCommandError(gettext(
@@ -2788,7 +2787,7 @@
                 location = '.'
             dir, relpath = controldir.ControlDir.open_containing(location)
             b = dir.open_branch()
-            self.add_cleanup(b.lock_read().unlock)
+            self.enter_context(b.lock_read())
             rev1, rev2 = _get_revision_range(revision, b, self.name())
 
         if b.get_config_stack().get('validate_signatures_in_log'):
@@ -3019,7 +3018,7 @@
                 view_str = views.view_display_str(view_files)
                 note(gettext("Ignoring files outside view. View is %s") % view_str)
 
-        self.add_cleanup(tree.lock_read().unlock)
+        self.enter_context(tree.lock_read())
         for fp, fc, fkind, entry in tree.list_files(
                 include_root=False, from_dir=relpath, recursive=recursive):
             # Apply additional masking
@@ -3196,7 +3195,7 @@
         ignores.tree_ignores_add_patterns(tree, name_pattern_list)
         ignored = globbing.Globster(name_pattern_list)
         matches = []
-        self.add_cleanup(tree.lock_read().unlock)
+        self.enter_context(tree.lock_read())
         for filename, fc, fkind, entry in tree.list_files():
             id = getattr(entry, 'file_id', None)
             if id is not None:
@@ -3227,7 +3226,7 @@
     @display_command
     def run(self, directory=u'.'):
         tree = WorkingTree.open_containing(directory)[0]
-        self.add_cleanup(tree.lock_read().unlock)
+        self.enter_context(tree.lock_read())
         for path, file_class, kind, entry in tree.list_files():
             if file_class != 'I':
                 continue
@@ -3318,7 +3317,7 @@
         (tree, b, subdir) = controldir.ControlDir.open_containing_tree_or_branch(
             branch_or_subdir)
         if tree is not None:
-            self.add_cleanup(tree.lock_read().unlock)
+            self.enter_context(tree.lock_read())
 
         if uncommitted:
             if tree is None:
@@ -3382,7 +3381,7 @@
                                                  " one revision specifier"))
         tree, branch, relpath = \
             _open_directory_or_containing_tree_or_branch(filename, directory)
-        self.add_cleanup(branch.lock_read().unlock)
+        self.enter_context(branch.lock_read())
         return self._run(tree, branch, relpath, filename, revision,
                          name_from_revision, filters)
 
@@ -3392,7 +3391,7 @@
         if tree is None:
             tree = b.basis_tree()
         rev_tree = _get_one_revision_tree('cat', revision, branch=b)
-        self.add_cleanup(rev_tree.lock_read().unlock)
+        self.enter_context(rev_tree.lock_read())
 
         if name_from_revision:
             # Try in revision if requested
@@ -3906,7 +3905,7 @@
                 c = Branch.open_containing(u'.')[0].get_config_stack()
             else:
                 b = Branch.open(directory)
-                self.add_cleanup(b.lock_write().unlock)
+                self.enter_context(b.lock_write())
                 c = b.get_config_stack()
         else:
             c = _mod_config.GlobalStack()
@@ -4284,8 +4283,8 @@
 
         branch1 = Branch.open_containing(branch)[0]
         branch2 = Branch.open_containing(other)[0]
-        self.add_cleanup(branch1.lock_read().unlock)
-        self.add_cleanup(branch2.lock_read().unlock)
+        self.enter_context(branch1.lock_read())
+        self.enter_context(branch2.lock_read())
         last1 = ensure_null(branch1.last_revision())
         last2 = ensure_null(branch2.last_revision())
 
@@ -4437,8 +4436,8 @@
         change_reporter = delta._ChangeReporter(
             unversioned_filter=tree.is_ignored, view_info=view_info)
         pb = ui.ui_factory.nested_progress_bar()
-        self.add_cleanup(pb.finished)
-        self.add_cleanup(tree.lock_write().unlock)
+        self.enter_context(pb)
+        self.enter_context(tree.lock_write())
         if location is not None:
             try:
                 mergeable = _mod_mergeable.read_mergeable_from_url(
@@ -4506,7 +4505,7 @@
     def _get_preview(self, merger):
         tree_merger = merger.make_merger()
         tt = tree_merger.make_preview_transform()
-        self.add_cleanup(tt.finalize)
+        self.enter_context(tt)
         result_tree = tt.get_preview_tree()
         return result_tree
 
@@ -4727,7 +4726,7 @@
         if merge_type is None:
             merge_type = _mod_merge.Merge3Merger
         tree, file_list = WorkingTree.open_containing_paths(file_list)
-        self.add_cleanup(tree.lock_write().unlock)
+        self.enter_context(tree.lock_write())
         parents = tree.get_parent_ids()
         if len(parents) != 2:
             raise errors.BzrCommandError(
@@ -4850,7 +4849,7 @@
     def run(self, revision=None, no_backup=False, file_list=None,
             forget_merges=None):
         tree, file_list = WorkingTree.open_containing_paths(file_list)
-        self.add_cleanup(tree.lock_tree_write().unlock)
+        self.enter_context(tree.lock_tree_write())
         if forget_merges:
             tree.set_parent_ids(tree.get_parent_ids()[:1])
         else:
@@ -4999,7 +4998,7 @@
             restrict = 'remote'
 
         local_branch = Branch.open_containing(directory)[0]
-        self.add_cleanup(local_branch.lock_read().unlock)
+        self.enter_context(local_branch.lock_read())
 
         parent = local_branch.get_parent()
         if other_branch is None:
@@ -5016,7 +5015,7 @@
         if remote_branch.base == local_branch.base:
             remote_branch = local_branch
         else:
-            self.add_cleanup(remote_branch.lock_read().unlock)
+            self.enter_context(remote_branch.lock_read())
 
         local_revid_range = _revision_range_to_revid_range(
             _get_revision_range(my_revision, local_branch,
@@ -5088,7 +5087,7 @@
             message(gettext("Branches are up to date.\n"))
         self.cleanup_now()
         if not status_code and parent is None and other_branch is not None:
-            self.add_cleanup(local_branch.lock_write().unlock)
+            self.enter_context(local_branch.lock_write())
             # handle race conditions - a parent might be set while we run.
             if local_branch.get_parent() is None:
                 local_branch.set_parent(remote_branch.base)
@@ -5181,7 +5180,7 @@
             b = Branch.open_containing(branch)[0]
         else:
             b = Branch.open(branch)
-        self.add_cleanup(b.lock_read().unlock)
+        self.enter_context(b.lock_read())
         if revision is None:
             rev_id = b.last_revision()
         else:
@@ -5224,11 +5223,11 @@
         wt, branch, relpath = \
             _open_directory_or_containing_tree_or_branch(filename, directory)
         if wt is not None:
-            self.add_cleanup(wt.lock_read().unlock)
+            self.enter_context(wt.lock_read())
         else:
-            self.add_cleanup(branch.lock_read().unlock)
+            self.enter_context(branch.lock_read())
         tree = _get_one_revision_tree('annotate', revision, branch=branch)
-        self.add_cleanup(tree.lock_read().unlock)
+        self.enter_context(tree.lock_read())
         if wt is not None and revision is None:
             if not wt.is_versioned(relpath):
                 raise errors.NotVersionedError(relpath)
@@ -5259,7 +5258,7 @@
             raise errors.BzrCommandError(
                 gettext('You must supply either --revision or a revision_id'))
         b = WorkingTree.open_containing(directory)[0].branch
-        self.add_cleanup(b.lock_write().unlock)
+        self.enter_context(b.lock_write())
         return self._run(b, revision_id_list, revision)
 
     def _run(self, b, revision_id_list, revision):
@@ -5405,9 +5404,9 @@
             b = control.open_branch()
 
         if tree is not None:
-            self.add_cleanup(tree.lock_write().unlock)
+            self.enter_context(tree.lock_write())
         else:
-            self.add_cleanup(b.lock_write().unlock)
+            self.enter_context(b.lock_write())
         return self._run(b, tree, dry_run, verbose, revision, force,
                          local, keep_tags, location)
 
@@ -5990,7 +5989,7 @@
             revision=None,
             ):
         branch, relpath = Branch.open_containing(directory)
-        self.add_cleanup(branch.lock_write().unlock)
+        self.enter_context(branch.lock_write())
         if delete:
             if tag_name is None:
                 raise errors.BzrCommandError(
@@ -6054,7 +6053,7 @@
         if not tags:
             return
 
-        self.add_cleanup(branch.lock_read().unlock)
+        self.enter_context(branch.lock_read())
         if revision:
             # Restrict to the specified range
             tags = self._tags_for_range(branch, revision)
@@ -6618,7 +6617,7 @@
         if directory is None:
             directory = u'.'
         tree = WorkingTree.open_containing(directory)[0]
-        self.add_cleanup(tree.lock_read().unlock)
+        self.enter_context(tree.lock_read())
         manager = tree.get_shelf_manager()
         shelves = manager.active_shelves()
         if len(shelves) == 0:

=== modified file 'breezy/bzr/bzrdir.py'
--- breezy/bzr/bzrdir.py	2019-06-29 13:16:26 +0000
+++ breezy/bzr/bzrdir.py	2019-07-27 23:18:50 +0000
@@ -319,17 +319,17 @@
         policy = self.determine_repository_policy(force_new_repo)
         return policy.acquire_repository()[0]
 
-    def _find_source_repo(self, add_cleanup, source_branch):
+    def _find_source_repo(self, exit_stack, source_branch):
         """Find the source branch and repo for a sprout operation.
 
         This is helper intended for use by _sprout.
 
         :returns: (source_branch, source_repository).  Either or both may be
             None.  If not None, they will be read-locked (and their unlock(s)
-            scheduled via the add_cleanup param).
+            scheduled via the exit_stack param).
         """
         if source_branch is not None:
-            add_cleanup(source_branch.lock_read().unlock)
+            exit_stack.enter_context(source_branch.lock_read())
             return source_branch, source_branch.repository
         try:
             source_branch = self.open_branch()
@@ -341,9 +341,9 @@
             except errors.NoRepositoryPresent:
                 source_repository = None
             else:
-                add_cleanup(source_repository.lock_read().unlock)
+                exit_stack.enter_context(source_repository.lock_read())
         else:
-            add_cleanup(source_branch.lock_read().unlock)
+            exit_stack.enter_context(source_branch.lock_read())
         return source_branch, source_repository
 
     def sprout(self, url, revision_id=None, force_new_repo=False,
@@ -376,115 +376,103 @@
             when working locally.
         :return: The created control directory
         """
-        operation = cleanup.OperationWithCleanups(self._sprout)
-        return operation.run(
-            url, revision_id=revision_id, force_new_repo=force_new_repo,
-            recurse=recurse, possible_transports=possible_transports,
-            accelerator_tree=accelerator_tree, hardlink=hardlink,
-            stacked=stacked, source_branch=source_branch,
-            create_tree_if_local=create_tree_if_local)
-
-    def _sprout(self, op, url, revision_id=None, force_new_repo=False,
-                recurse='down', possible_transports=None,
-                accelerator_tree=None, hardlink=False, stacked=False,
-                source_branch=None, create_tree_if_local=True, lossy=False):
-        add_cleanup = op.add_cleanup
-        fetch_spec_factory = fetch.FetchSpecFactory()
-        if revision_id is not None:
-            fetch_spec_factory.add_revision_ids([revision_id])
-            fetch_spec_factory.source_branch_stop_revision_id = revision_id
-        if possible_transports is None:
-            possible_transports = []
-        else:
-            possible_transports = list(possible_transports) + [
-                self.root_transport]
-        target_transport = _mod_transport.get_transport(url,
-                                                        possible_transports)
-        target_transport.ensure_base()
-        cloning_format = self.cloning_metadir(stacked)
-        # Create/update the result branch
-        try:
-            result = controldir.ControlDir.open_from_transport(
-                target_transport)
-        except errors.NotBranchError:
-            result = cloning_format.initialize_on_transport(target_transport)
-        source_branch, source_repository = self._find_source_repo(
-            add_cleanup, source_branch)
-        fetch_spec_factory.source_branch = source_branch
-        # if a stacked branch wasn't requested, we don't create one
-        # even if the origin was stacked
-        if stacked and source_branch is not None:
-            stacked_branch_url = self.root_transport.base
-        else:
-            stacked_branch_url = None
-        repository_policy = result.determine_repository_policy(
-            force_new_repo, stacked_branch_url, require_stacking=stacked)
-        result_repo, is_new_repo = repository_policy.acquire_repository(
-            possible_transports=possible_transports)
-        add_cleanup(result_repo.lock_write().unlock)
-        fetch_spec_factory.source_repo = source_repository
-        fetch_spec_factory.target_repo = result_repo
-        if stacked or (len(result_repo._fallback_repositories) != 0):
-            target_repo_kind = fetch.TargetRepoKinds.STACKED
-        elif is_new_repo:
-            target_repo_kind = fetch.TargetRepoKinds.EMPTY
-        else:
-            target_repo_kind = fetch.TargetRepoKinds.PREEXISTING
-        fetch_spec_factory.target_repo_kind = target_repo_kind
-        if source_repository is not None:
-            fetch_spec = fetch_spec_factory.make_fetch_spec()
-            result_repo.fetch(source_repository, fetch_spec=fetch_spec)
-
-        if source_branch is None:
-            # this is for sprouting a controldir without a branch; is that
-            # actually useful?
-            # Not especially, but it's part of the contract.
-            result_branch = result.create_branch()
-        else:
-            result_branch = source_branch.sprout(
-                result, revision_id=revision_id,
-                repository_policy=repository_policy, repository=result_repo)
-        mutter("created new branch %r" % (result_branch,))
-
-        # Create/update the result working tree
-        if (create_tree_if_local and not result.has_workingtree()
-                and isinstance(target_transport, local.LocalTransport)
-                and (result_repo is None or result_repo.make_working_trees())
-                and result.open_branch(
-                    name="",
-                    possible_transports=possible_transports).name == result_branch.name):
-            wt = result.create_workingtree(
-                accelerator_tree=accelerator_tree, hardlink=hardlink,
-                from_branch=result_branch)
-            with wt.lock_write():
-                if not wt.is_versioned(''):
-                    try:
-                        wt.set_root_id(self.open_workingtree.path2id(''))
-                    except errors.NoWorkingTree:
-                        pass
-        else:
-            wt = None
-        if recurse == 'down':
-            basis = None
-            if wt is not None:
-                basis = wt.basis_tree()
-            elif result_branch is not None:
-                basis = result_branch.basis_tree()
-            elif source_branch is not None:
-                basis = source_branch.basis_tree()
-            if basis is not None:
-                add_cleanup(basis.lock_read().unlock)
-                subtrees = basis.iter_references()
-            else:
-                subtrees = []
-            for path in subtrees:
-                target = urlutils.join(url, urlutils.escape(path))
-                sublocation = source_branch.reference_parent(path)
-                sublocation.controldir.sprout(
-                    target, basis.get_reference_revision(path),
-                    force_new_repo=force_new_repo, recurse=recurse,
-                    stacked=stacked)
-        return result
+        with cleanup.ExitStack() as stack:
+            fetch_spec_factory = fetch.FetchSpecFactory()
+            if revision_id is not None:
+                fetch_spec_factory.add_revision_ids([revision_id])
+                fetch_spec_factory.source_branch_stop_revision_id = revision_id
+            if possible_transports is None:
+                possible_transports = []
+            else:
+                possible_transports = list(possible_transports) + [
+                    self.root_transport]
+            target_transport = _mod_transport.get_transport(url,
+                                                            possible_transports)
+            target_transport.ensure_base()
+            cloning_format = self.cloning_metadir(stacked)
+            # Create/update the result branch
+            try:
+                result = controldir.ControlDir.open_from_transport(
+                    target_transport)
+            except errors.NotBranchError:
+                result = cloning_format.initialize_on_transport(target_transport)
+            source_branch, source_repository = self._find_source_repo(
+                stack, source_branch)
+            fetch_spec_factory.source_branch = source_branch
+            # if a stacked branch wasn't requested, we don't create one
+            # even if the origin was stacked
+            if stacked and source_branch is not None:
+                stacked_branch_url = self.root_transport.base
+            else:
+                stacked_branch_url = None
+            repository_policy = result.determine_repository_policy(
+                force_new_repo, stacked_branch_url, require_stacking=stacked)
+            result_repo, is_new_repo = repository_policy.acquire_repository(
+                possible_transports=possible_transports)
+            stack.enter_context(result_repo.lock_write())
+            fetch_spec_factory.source_repo = source_repository
+            fetch_spec_factory.target_repo = result_repo
+            if stacked or (len(result_repo._fallback_repositories) != 0):
+                target_repo_kind = fetch.TargetRepoKinds.STACKED
+            elif is_new_repo:
+                target_repo_kind = fetch.TargetRepoKinds.EMPTY
+            else:
+                target_repo_kind = fetch.TargetRepoKinds.PREEXISTING
+            fetch_spec_factory.target_repo_kind = target_repo_kind
+            if source_repository is not None:
+                fetch_spec = fetch_spec_factory.make_fetch_spec()
+                result_repo.fetch(source_repository, fetch_spec=fetch_spec)
+
+            if source_branch is None:
+                # this is for sprouting a controldir without a branch; is that
+                # actually useful?
+                # Not especially, but it's part of the contract.
+                result_branch = result.create_branch()
+            else:
+                result_branch = source_branch.sprout(
+                    result, revision_id=revision_id,
+                    repository_policy=repository_policy, repository=result_repo)
+            mutter("created new branch %r" % (result_branch,))
+
+            # Create/update the result working tree
+            if (create_tree_if_local and not result.has_workingtree()
+                    and isinstance(target_transport, local.LocalTransport)
+                    and (result_repo is None or result_repo.make_working_trees())
+                    and result.open_branch(
+                        name="",
+                        possible_transports=possible_transports).name == result_branch.name):
+                wt = result.create_workingtree(
+                    accelerator_tree=accelerator_tree, hardlink=hardlink,
+                    from_branch=result_branch)
+                with wt.lock_write():
+                    if not wt.is_versioned(''):
+                        try:
+                            wt.set_root_id(self.open_workingtree.path2id(''))
+                        except errors.NoWorkingTree:
+                            pass
+            else:
+                wt = None
+            if recurse == 'down':
+                basis = None
+                if wt is not None:
+                    basis = wt.basis_tree()
+                elif result_branch is not None:
+                    basis = result_branch.basis_tree()
+                elif source_branch is not None:
+                    basis = source_branch.basis_tree()
+                if basis is not None:
+                    stack.enter_context(basis.lock_read())
+                    subtrees = basis.iter_references()
+                else:
+                    subtrees = []
+                for path in subtrees:
+                    target = urlutils.join(url, urlutils.escape(path))
+                    sublocation = source_branch.reference_parent(path)
+                    sublocation.controldir.sprout(
+                        target, basis.get_reference_revision(path),
+                        force_new_repo=force_new_repo, recurse=recurse,
+                        stacked=stacked)
+            return result
 
     def _available_backup_name(self, base):
         """Find a non-existing backup file name based on base.

=== modified file 'breezy/bzr/dirstate.py'
--- breezy/bzr/dirstate.py	2019-06-16 23:54:50 +0000
+++ breezy/bzr/dirstate.py	2019-07-27 23:18:50 +0000
@@ -235,6 +235,7 @@
     )
 from .. import (
     cache_utf8,
+    cleanup,
     config,
     debug,
     errors,
@@ -1311,21 +1312,18 @@
         result = DirState.initialize(dir_state_filename,
                                      sha1_provider=sha1_provider)
         try:
-            with tree.lock_read():
-                try:
-                    parent_ids = tree.get_parent_ids()
-                    num_parents = len(parent_ids)
-                    parent_trees = []
-                    for parent_id in parent_ids:
-                        parent_tree = tree.branch.repository.revision_tree(
-                            parent_id)
-                        parent_trees.append((parent_id, parent_tree))
-                        parent_tree.lock_read()
-                    result.set_parent_trees(parent_trees, [])
-                    result.set_state_from_inventory(tree.root_inventory)
-                finally:
-                    for revid, parent_tree in parent_trees:
-                        parent_tree.unlock()
+            with cleanup.ExitStack() as exit_stack:
+                exit_stack.enter_context(tree.lock_read())
+                parent_ids = tree.get_parent_ids()
+                num_parents = len(parent_ids)
+                parent_trees = []
+                for parent_id in parent_ids:
+                    parent_tree = tree.branch.repository.revision_tree(
+                        parent_id)
+                    parent_trees.append((parent_id, parent_tree))
+                    exit_stack.enter_context(parent_tree.lock_read())
+                result.set_parent_trees(parent_trees, [])
+                result.set_state_from_inventory(tree.root_inventory)
         except:
             # The caller won't have a chance to unlock this, so make sure we
             # cleanup ourselves

=== modified file 'breezy/bzr/pack_repo.py'
--- breezy/bzr/pack_repo.py	2018-11-30 12:39:04 +0000
+++ breezy/bzr/pack_repo.py	2019-07-27 23:18:50 +0000
@@ -1550,21 +1550,21 @@
         # FIXME: just drop the transient index.
         # forget what names there are
         if self._new_pack is not None:
-            operation = cleanup.OperationWithCleanups(self._new_pack.abort)
-            operation.add_cleanup(setattr, self, '_new_pack', None)
-            # If we aborted while in the middle of finishing the write
-            # group, _remove_pack_indices could fail because the indexes are
-            # already gone.  But they're not there we shouldn't fail in this
-            # case, so we pass ignore_missing=True.
-            operation.add_cleanup(self._remove_pack_indices, self._new_pack,
-                                  ignore_missing=True)
-            operation.run_simple()
+            with cleanup.ExitStack() as stack:
+                stack.callback(setattr, self, '_new_pack', None)
+                # If we aborted while in the middle of finishing the write
+                # group, _remove_pack_indices could fail because the indexes are
+                # already gone.  But they're not there we shouldn't fail in this
+                # case, so we pass ignore_missing=True.
+                stack.callback(self._remove_pack_indices, self._new_pack,
+                               ignore_missing=True)
+                self._new_pack.abort()
         for resumed_pack in self._resumed_packs:
-            operation = cleanup.OperationWithCleanups(resumed_pack.abort)
-            # See comment in previous finally block.
-            operation.add_cleanup(self._remove_pack_indices, resumed_pack,
-                                  ignore_missing=True)
-            operation.run_simple()
+            with cleanup.ExitStack() as stack:
+                # See comment in previous finally block.
+                stack.callback(self._remove_pack_indices, resumed_pack,
+                               ignore_missing=True)
+                resumed_pack.abort()
         del self._resumed_packs[:]
 
     def _remove_resumed_pack_indices(self):

=== modified file 'breezy/bzr/workingtree_4.py'
--- breezy/bzr/workingtree_4.py	2019-07-25 23:22:30 +0000
+++ breezy/bzr/workingtree_4.py	2019-07-27 23:18:50 +0000
@@ -693,14 +693,14 @@
 
             # GZ 2017-03-28: The rollbacks variable was shadowed in the loop below
             # missing those added here, but there's also no test coverage for this.
-            rollbacks = cleanup.ObjectWithCleanups()
+            rollbacks = cleanup.ExitStack()
 
             def move_one(old_entry, from_path_utf8, minikind, executable,
                          fingerprint, packed_stat, size,
                          to_block, to_key, to_path_utf8):
                 state._make_absent(old_entry)
                 from_key = old_entry[0]
-                rollbacks.add_cleanup(
+                rollbacks.callback(
                     state.update_minimal,
                     from_key,
                     minikind,
@@ -719,7 +719,7 @@
                 added_entry_index, _ = state._find_entry_index(
                     to_key, to_block[1])
                 new_entry = to_block[1][added_entry_index]
-                rollbacks.add_cleanup(state._make_absent, new_entry)
+                rollbacks.callback(state._make_absent, new_entry)
 
             for from_rel in from_paths:
                 # from_rel is 'pathinroot/foo/bar'
@@ -776,7 +776,7 @@
                         osutils.rename(from_rel_abs, to_rel_abs)
                     except OSError as e:
                         raise errors.BzrMoveFailedError(from_rel, to_rel, e[1])
-                    rollbacks.add_cleanup(
+                    rollbacks.callback(
                         osutils.rename, to_rel_abs, from_rel_abs)
                 try:
                     # perform the rename in the inventory next if needed: its easy
@@ -786,7 +786,7 @@
                         from_entry = inv.get_entry(from_id)
                         current_parent = from_entry.parent_id
                         inv.rename(from_id, to_dir_id, from_tail)
-                        rollbacks.add_cleanup(
+                        rollbacks.callback(
                             inv.rename, from_id, current_parent, from_tail)
                     # finally do the rename in the dirstate, which is a little
                     # tricky to rollback, but least likely to need it.
@@ -867,7 +867,7 @@
                                                     to_path_utf8)
                         update_dirblock(from_rel_utf8, to_key, to_rel_utf8)
                 except BaseException:
-                    rollbacks.cleanup_now()
+                    rollbacks.close()
                     raise
                 result.append((from_rel, to_rel))
                 state._mark_modified()

=== modified file 'breezy/check.py'
--- breezy/check.py	2019-07-07 17:24:23 +0000
+++ breezy/check.py	2019-07-27 23:18:50 +0000
@@ -37,6 +37,7 @@
 from __future__ import absolute_import
 
 from . import (
+    cleanup,
     errors,
     )
 from .controldir import ControlDir
@@ -54,36 +55,34 @@
         raise NotImplementedError(self.report_results)
 
 
-def scan_branch(branch, needed_refs, to_unlock):
+def scan_branch(branch, needed_refs, exit_stack):
     """Scan a branch for refs.
 
     :param branch:  The branch to schedule for checking.
     :param needed_refs: Refs we are accumulating.
-    :param to_unlock: The unlock list accumulating.
+    :param exit_stack: The exit stack accumulating.
     """
     note(gettext("Checking branch at '%s'.") % (branch.base,))
-    branch.lock_read()
-    to_unlock.append(branch)
+    exit_stack.enter_context(branch.lock_read())
     branch_refs = branch._get_check_refs()
     for ref in branch_refs:
         reflist = needed_refs.setdefault(ref, [])
         reflist.append(branch)
 
 
-def scan_tree(base_tree, tree, needed_refs, to_unlock):
+def scan_tree(base_tree, tree, needed_refs, exit_stack):
     """Scan a tree for refs.
 
     :param base_tree: The original tree check opened, used to detect duplicate
         tree checks.
     :param tree:  The tree to schedule for checking.
     :param needed_refs: Refs we are accumulating.
-    :param to_unlock: The unlock list accumulating.
+    :param exit_stack: The exit stack accumulating.
     """
     if base_tree is not None and tree.basedir == base_tree.basedir:
         return
     note(gettext("Checking working tree at '%s'.") % (tree.basedir,))
-    tree.lock_read()
-    to_unlock.append(tree)
+    exit_stack.enter_context(tree.lock_read())
     tree_refs = tree._get_check_refs()
     for ref in tree_refs:
         reflist = needed_refs.setdefault(ref, [])
@@ -102,14 +101,13 @@
     except errors.NotBranchError:
         base_tree = branch = repo = None
 
-    to_unlock = []
-    needed_refs = {}
-    try:
+    with cleanup.ExitStack() as exit_stack:
+        needed_refs = {}
         if base_tree is not None:
             # If the tree is a lightweight checkout we won't see it in
             # repo.find_branches - add now.
             if do_tree:
-                scan_tree(None, base_tree, needed_refs, to_unlock)
+                scan_tree(None, base_tree, needed_refs, exit_stack)
             branch = base_tree.branch
         if branch is not None:
             # We have a branch
@@ -117,8 +115,7 @@
                 # The branch is in a shared repository
                 repo = branch.repository
         if repo is not None:
-            repo.lock_read()
-            to_unlock.append(repo)
+            exit_stack.enter_context(repo.lock_read())
             branches = list(repo.find_branches(using=True))
             saw_tree = False
             if do_branch or do_tree:
@@ -130,9 +127,9 @@
                         except (errors.NotLocalUrl, errors.NoWorkingTree):
                             pass
                         else:
-                            scan_tree(base_tree, tree, needed_refs, to_unlock)
+                            scan_tree(base_tree, tree, needed_refs, exit_stack)
                     if do_branch:
-                        scan_branch(branch, needed_refs, to_unlock)
+                        scan_branch(branch, needed_refs, exit_stack)
             if do_branch and not branches:
                 note(gettext("No branch found at specified location."))
             if do_tree and base_tree is None and not saw_tree:
@@ -151,6 +148,3 @@
                 note(gettext("No branch found at specified location."))
             if do_repo:
                 note(gettext("No repository found at specified location."))
-    finally:
-        for thing in to_unlock:
-            thing.unlock()

=== modified file 'breezy/cleanup.py'
--- breezy/cleanup.py	2018-11-12 01:41:38 +0000
+++ breezy/cleanup.py	2019-07-27 23:18:50 +0000
@@ -16,166 +16,188 @@
 
 """Helpers for managing cleanup functions and the errors they might raise.
 
-The usual way to run cleanup code in Python is::
-
-    try:
-        do_something()
-    finally:
-        cleanup_something()
-
-However if both `do_something` and `cleanup_something` raise an exception
-Python will forget the original exception and propagate the one from
-cleanup_something.  Unfortunately, this is almost always much less useful than
-the original exception.
-
-If you want to be certain that the first, and only the first, error is raised,
-then use::
-
-    operation = OperationWithCleanups(do_something)
-    operation.add_cleanup(cleanup_something)
-    operation.run_simple()
-
-This is more inconvenient (because you need to make every try block a
-function), but will ensure that the first error encountered is the one raised,
-while also ensuring all cleanups are run.  See OperationWithCleanups for more
-details.
+This currently just contains a copy of contextlib.ExitStack, available
+even on older versions of Python.
 """
 
 from __future__ import absolute_import
 
 from collections import deque
-from . import (
-    debug,
-    trace,
-    )
-
-
-def _log_cleanup_error(exc):
-    trace.mutter('Cleanup failed:')
-    trace.log_exception_quietly()
-    if 'cleanup' in debug.debug_flags:
-        trace.warning('brz: warning: Cleanup failed: %s', exc)
-
-
-def _run_cleanup(func, *args, **kwargs):
-    """Run func(*args, **kwargs), logging but not propagating any error it
-    raises.
-
-    :returns: True if func raised no errors, else False.
-    """
-    try:
-        func(*args, **kwargs)
-    except KeyboardInterrupt:
-        raise
-    except Exception as exc:
-        _log_cleanup_error(exc)
-        return False
-    return True
-
-
-def _run_cleanups(funcs):
-    """Run a series of cleanup functions."""
-    for func, args, kwargs in funcs:
-        _run_cleanup(func, *args, **kwargs)
-
-
-class ObjectWithCleanups(object):
-    """A mixin for objects that hold a cleanup list.
-
-    Subclass or client code can call add_cleanup and then later `cleanup_now`.
-    """
-
-    def __init__(self):
-        self.cleanups = deque()
-
-    def add_cleanup(self, cleanup_func, *args, **kwargs):
-        """Add a cleanup to run.
-
-        Cleanups may be added at any time.
-        Cleanups will be executed in LIFO order.
+import sys
+
+
+try:
+    from contextlib import ExitStack
+except ImportError:
+    # Copied from the Python standard library on Python 3.4.
+    # Copyright: Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
+    #   2009, 2010, 2011 Python Software Foundation
+    #
+    # PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
+    # --------------------------------------------
+    # .
+    # 1. This LICENSE AGREEMENT is between the Python Software Foundation
+    # ("PSF"), and the Individual or Organization ("Licensee") accessing and
+    # otherwise using this software ("Python") in source or binary form and
+    # its associated documentation.
+    # .
+    # 2. Subject to the terms and conditions of this License Agreement, PSF hereby
+    # grants Licensee a nonexclusive, royalty-free, world-wide license to reproduce,
+    # analyze, test, perform and/or display publicly, prepare derivative works,
+    # distribute, and otherwise use Python alone or in any derivative version,
+    # provided, however, that PSF's License Agreement and PSF's notice of copyright,
+    # i.e., "Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
+    # 2011 Python Software Foundation; All Rights Reserved" are retained in Python
+    # alone or in any derivative version prepared by Licensee.
+    # .
+    # 3. In the event Licensee prepares a derivative work that is based on
+    # or incorporates Python or any part thereof, and wants to make
+    # the derivative work available to others as provided herein, then
+    # Licensee hereby agrees to include in any such work a brief summary of
+    # the changes made to Python.
+    # .
+    # 4. PSF is making Python available to Licensee on an "AS IS"
+    # basis.  PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
+    # IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND
+    # DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
+    # FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON WILL NOT
+    # INFRINGE ANY THIRD PARTY RIGHTS.
+    # .
+    # 5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON
+    # FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS
+    # A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON,
+    # OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
+    # .
+    # 6. This License Agreement will automatically terminate upon a material
+    # breach of its terms and conditions.
+    # .
+    # 7. Nothing in this License Agreement shall be deemed to create any
+    # relationship of agency, partnership, or joint venture between PSF and
+    # Licensee.  This License Agreement does not grant permission to use PSF
+    # trademarks or trade name in a trademark sense to endorse or promote
+    # products or services of Licensee, or any third party.
+    # .
+    # 8. By copying, installing or otherwise using Python, Licensee
+    # agrees to be bound by the terms and conditions of this License
+    # Agreement.
+
+    def _reraise_with_existing_context(exc_details):
+        # Use 3 argument raise in Python 2,
+        # but use exec to avoid SyntaxError in Python 3
+        exc_type, exc_value, exc_tb = exc_details
+        exec("raise exc_type, exc_value, exc_tb")
+
+
+    # Inspired by discussions on http://bugs.python.org/issue13585
+    class ExitStack(object):
+        """Context manager for dynamic management of a stack of exit callbacks
+
+        For example:
+
+            with ExitStack() as stack:
+                files = [stack.enter_context(open(fname)) for fname in filenames]
+                # All opened files will automatically be closed at the end of
+                # the with statement, even if attempts to open files later
+                # in the list raise an exception
+
         """
-        self.cleanups.appendleft((cleanup_func, args, kwargs))
-
-    def cleanup_now(self):
-        _run_cleanups(self.cleanups)
-        self.cleanups.clear()
-
-
-class OperationWithCleanups(ObjectWithCleanups):
-    """A way to run some code with a dynamic cleanup list.
-
-    This provides a way to add cleanups while the function-with-cleanups is
-    running.
-
-    Typical use::
-
-        operation = OperationWithCleanups(some_func)
-        operation.run(args...)
-
-    where `some_func` is::
-
-        def some_func(operation, args, ...):
-            do_something()
-            operation.add_cleanup(something)
-            # etc
-
-    Note that the first argument passed to `some_func` will be the
-    OperationWithCleanups object.  To invoke `some_func` without that, use
-    `run_simple` instead of `run`.
-    """
-
-    def __init__(self, func):
-        super(OperationWithCleanups, self).__init__()
-        self.func = func
-
-    def run(self, *args, **kwargs):
-        return _do_with_cleanups(
-            self.cleanups, self.func, self, *args, **kwargs)
-
-    def run_simple(self, *args, **kwargs):
-        return _do_with_cleanups(
-            self.cleanups, self.func, *args, **kwargs)
-
-
-def _do_with_cleanups(cleanup_funcs, func, *args, **kwargs):
-    """Run `func`, then call all the cleanup_funcs.
-
-    All the cleanup_funcs are guaranteed to be run.  The first exception raised
-    by func or any of the cleanup_funcs is the one that will be propagted by
-    this function (subsequent errors are caught and logged).
-
-    Conceptually similar to::
-
-        try:
-            return func(*args, **kwargs)
-        finally:
-            for cleanup, cargs, ckwargs in cleanup_funcs:
-                cleanup(*cargs, **ckwargs)
-
-    It avoids several problems with using try/finally directly:
-     * an exception from func will not be obscured by a subsequent exception
-       from a cleanup.
-     * an exception from a cleanup will not prevent other cleanups from
-       running (but the first exception encountered is still the one
-       propagated).
-
-    Unike `_run_cleanup`, `_do_with_cleanups` can propagate an exception from a
-    cleanup, but only if there is no exception from func.
-    """
-    try:
-        result = func(*args, **kwargs)
-    except BaseException:
-        # We have an exception from func already, so suppress cleanup errors.
-        _run_cleanups(cleanup_funcs)
-        raise
-    # No exception from func, so allow first cleanup error to propgate.
-    pending_cleanups = iter(cleanup_funcs)
-    try:
-        for cleanup, c_args, c_kwargs in pending_cleanups:
-            cleanup(*c_args, **c_kwargs)
-    except BaseException:
-        # Still run the remaining cleanups but suppress any further errors.
-        _run_cleanups(pending_cleanups)
-        raise
-    # No error, so we can return the result
-    return result
+        def __init__(self):
+            self._exit_callbacks = deque()
+
+        def pop_all(self):
+            """Preserve the context stack by transferring it to a new instance"""
+            new_stack = type(self)()
+            new_stack._exit_callbacks = self._exit_callbacks
+            self._exit_callbacks = deque()
+            return new_stack
+
+        def _push_cm_exit(self, cm, cm_exit):
+            """Helper to correctly register callbacks to __exit__ methods"""
+            def _exit_wrapper(*exc_details):
+                return cm_exit(cm, *exc_details)
+            _exit_wrapper.__self__ = cm
+            self.push(_exit_wrapper)
+
+        def push(self, exit):
+            """Registers a callback with the standard __exit__ method signature
+
+            Can suppress exceptions the same way __exit__ methods can.
+
+            Also accepts any object with an __exit__ method (registering a call
+            to the method instead of the object itself)
+            """
+            # We use an unbound method rather than a bound method to follow
+            # the standard lookup behaviour for special methods
+            _cb_type = type(exit)
+            try:
+                exit_method = _cb_type.__exit__
+            except AttributeError:
+                # Not a context manager, so assume its a callable
+                self._exit_callbacks.append(exit)
+            else:
+                self._push_cm_exit(exit, exit_method)
+            return exit # Allow use as a decorator
+
+        def callback(self, callback, *args, **kwds):
+            """Registers an arbitrary callback and arguments.
+
+            Cannot suppress exceptions.
+            """
+            def _exit_wrapper(exc_type, exc, tb):
+                callback(*args, **kwds)
+            # We changed the signature, so using @wraps is not appropriate, but
+            # setting __wrapped__ may still help with introspection
+            _exit_wrapper.__wrapped__ = callback
+            self.push(_exit_wrapper)
+            return callback # Allow use as a decorator
+
+        def enter_context(self, cm):
+            """Enters the supplied context manager
+
+            If successful, also pushes its __exit__ method as a callback and
+            returns the result of the __enter__ method.
+            """
+            # We look up the special methods on the type to match the with statement
+            _cm_type = type(cm)
+            _exit = _cm_type.__exit__
+            result = _cm_type.__enter__(cm)
+            self._push_cm_exit(cm, _exit)
+            return result
+
+        def close(self):
+            """Immediately unwind the context stack"""
+            self.__exit__(None, None, None)
+
+        def __enter__(self):
+            return self
+
+        def __exit__(self, *exc_details):
+            received_exc = exc_details[0] is not None
+
+            # We manipulate the exception state so it behaves as though
+            # we were actually nesting multiple with statements
+            frame_exc = sys.exc_info()[1]
+            def _make_context_fixer(frame_exc):
+                return lambda new_exc, old_exc: None
+            _fix_exception_context = _make_context_fixer(frame_exc)
+
+            # Callbacks are invoked in LIFO order to match the behaviour of
+            # nested context managers
+            suppressed_exc = False
+            pending_raise = False
+            while self._exit_callbacks:
+                cb = self._exit_callbacks.pop()
+                try:
+                    if cb(*exc_details):
+                        suppressed_exc = True
+                        pending_raise = False
+                        exc_details = (None, None, None)
+                except:
+                    new_exc_details = sys.exc_info()
+                    # simulate the stack of exceptions by setting the context
+                    _fix_exception_context(new_exc_details[1], exc_details[1])
+                    pending_raise = True
+                    exc_details = new_exc_details
+            if pending_raise:
+                _reraise_with_existing_context(exc_details)
+            return received_exc and suppressed_exc

=== modified file 'breezy/commands.py'
--- breezy/commands.py	2019-03-02 21:46:18 +0000
+++ breezy/commands.py	2019-07-27 23:18:50 +0000
@@ -496,7 +496,7 @@
 
         Functions will be called in LIFO order.
         """
-        self._operation.add_cleanup(cleanup_func, *args, **kwargs)
+        self._exit_stack.callback(cleanup_func, *args, **kwargs)
 
     def cleanup_now(self):
         """Execute and empty pending cleanup functions immediately.
@@ -511,7 +511,10 @@
         as it releases all resources, this may release locks that the command
         wants to hold, so use should be done with care.
         """
-        self._operation.cleanup_now()
+        self._exit_stack.close()
+
+    def enter_context(self, cm):
+        return self._exit_stack.enter_context(cm)
 
     def _usage(self):
         """Return single-line grammar for this command.
@@ -779,11 +782,10 @@
         def run(*args, **kwargs):
             for hook in Command.hooks['pre_command']:
                 hook(self)
-            self._operation = cleanup.OperationWithCleanups(class_run)
             try:
-                return self._operation.run_simple(*args, **kwargs)
+                with cleanup.ExitStack() as self._exit_stack:
+                    return class_run(*args, **kwargs)
             finally:
-                del self._operation
                 for hook in Command.hooks['post_command']:
                     hook(self)
         self.run = run
@@ -799,7 +801,7 @@
         an exception to raise up.
 
         This method is automatically wrapped by Command.__init__ with a
-        cleanup operation, stored as self._operation. This can be used
+        ExitStack, stored as self._exit_stack. This can be used
         via self.add_cleanup to perform automatic cleanups at the end of
         run().
 

=== modified file 'breezy/commit.py'
--- breezy/commit.py	2019-06-22 12:31:14 +0000
+++ breezy/commit.py	2019-07-27 23:18:50 +0000
@@ -57,7 +57,7 @@
     ui,
     )
 from .branch import Branch
-from .cleanup import OperationWithCleanups
+from .cleanup import ExitStack
 import breezy.config
 from .errors import (BzrError,
                      ConflictsInTree,
@@ -285,192 +285,166 @@
         :param lossy: When committing to a foreign VCS, ignore any
             data that can not be natively represented.
         """
-        operation = OperationWithCleanups(self._commit)
-        self.revprops = revprops or {}
-        # XXX: Can be set on __init__ or passed in - this is a bit ugly.
-        self.config_stack = config or self.config_stack
-        return operation.run(
-            message=message,
-            timestamp=timestamp,
-            timezone=timezone,
-            committer=committer,
-            specific_files=specific_files,
-            rev_id=rev_id,
-            allow_pointless=allow_pointless,
-            strict=strict,
-            verbose=verbose,
-            working_tree=working_tree,
-            local=local,
-            reporter=reporter,
-            message_callback=message_callback,
-            recursive=recursive,
-            exclude=exclude,
-            possible_master_transports=possible_master_transports,
-            lossy=lossy)
-
-    def _commit(self, operation, message, timestamp, timezone, committer,
-                specific_files, rev_id, allow_pointless, strict, verbose,
-                working_tree, local, reporter, message_callback, recursive,
-                exclude, possible_master_transports, lossy):
-        mutter('preparing to commit')
-
-        if working_tree is None:
-            raise BzrError("working_tree must be passed into commit().")
-        else:
-            self.work_tree = working_tree
-            self.branch = self.work_tree.branch
-            if getattr(self.work_tree, 'requires_rich_root', lambda: False)():
-                if not self.branch.repository.supports_rich_root():
-                    raise errors.RootNotRich()
-        if message_callback is None:
-            if message is not None:
-                if isinstance(message, bytes):
-                    message = message.decode(get_user_encoding())
-
-                def message_callback(x):
-                    return message
-            else:
-                raise BzrError("The message or message_callback keyword"
-                               " parameter is required for commit().")
-
-        self.bound_branch = None
-        self.any_entries_deleted = False
-        if exclude is not None:
-            self.exclude = sorted(
-                minimum_path_selection(exclude))
-        else:
-            self.exclude = []
-        self.local = local
-        self.master_branch = None
-        self.recursive = recursive
-        self.rev_id = None
-        # self.specific_files is None to indicate no filter, or any iterable to
-        # indicate a filter - [] means no files at all, as per iter_changes.
-        if specific_files is not None:
-            self.specific_files = sorted(
-                minimum_path_selection(specific_files))
-        else:
-            self.specific_files = None
-
-        self.allow_pointless = allow_pointless
-        self.message_callback = message_callback
-        self.timestamp = timestamp
-        self.timezone = timezone
-        self.committer = committer
-        self.strict = strict
-        self.verbose = verbose
-
-        self.work_tree.lock_write()
-        operation.add_cleanup(self.work_tree.unlock)
-        self.parents = self.work_tree.get_parent_ids()
-        self.pb = ui.ui_factory.nested_progress_bar()
-        operation.add_cleanup(self.pb.finished)
-        self.basis_revid = self.work_tree.last_revision()
-        self.basis_tree = self.work_tree.basis_tree()
-        self.basis_tree.lock_read()
-        operation.add_cleanup(self.basis_tree.unlock)
-        # Cannot commit with conflicts present.
-        if len(self.work_tree.conflicts()) > 0:
-            raise ConflictsInTree
-
-        # Setup the bound branch variables as needed.
-        self._check_bound_branch(operation, possible_master_transports)
-
-        if self.config_stack is None:
-            self.config_stack = self.work_tree.get_config_stack()
-
-        # Check that the working tree is up to date
-        old_revno, old_revid, new_revno = self._check_out_of_date_tree()
-
-        # Complete configuration setup
-        if reporter is not None:
-            self.reporter = reporter
-        elif self.reporter is None:
-            self.reporter = self._select_reporter()
-
-        # Setup the progress bar. As the number of files that need to be
-        # committed in unknown, progress is reported as stages.
-        # We keep track of entries separately though and include that
-        # information in the progress bar during the relevant stages.
-        self.pb_stage_name = ""
-        self.pb_stage_count = 0
-        self.pb_stage_total = 5
-        if self.bound_branch:
-            # 2 extra stages: "Uploading data to master branch" and "Merging
-            # tags to master branch"
-            self.pb_stage_total += 2
-        self.pb.show_pct = False
-        self.pb.show_spinner = False
-        self.pb.show_eta = False
-        self.pb.show_count = True
-        self.pb.show_bar = True
-
-        # After a merge, a selected file commit is not supported.
-        # See 'bzr help merge' for an explanation as to why.
-        if len(self.parents) > 1 and self.specific_files is not None:
-            raise CannotCommitSelectedFileMerge(self.specific_files)
-        # Excludes are a form of selected file commit.
-        if len(self.parents) > 1 and self.exclude:
-            raise CannotCommitSelectedFileMerge(self.exclude)
-
-        # Collect the changes
-        self._set_progress_stage("Collecting changes", counter=True)
-        self._lossy = lossy
-        self.builder = self.branch.get_commit_builder(
-            self.parents, self.config_stack, timestamp, timezone, committer,
-            self.revprops, rev_id, lossy=lossy)
-
-        if self.builder.updates_branch and self.bound_branch:
-            self.builder.abort()
-            raise AssertionError(
-                "bound branches not supported for commit builders "
-                "that update the branch")
-
-        try:
-            # find the location being committed to
+        with ExitStack() as stack:
+            self.revprops = revprops or {}
+            # XXX: Can be set on __init__ or passed in - this is a bit ugly.
+            self.config_stack = config or self.config_stack
+            mutter('preparing to commit')
+
+            if working_tree is None:
+                raise BzrError("working_tree must be passed into commit().")
+            else:
+                self.work_tree = working_tree
+                self.branch = self.work_tree.branch
+                if getattr(self.work_tree, 'requires_rich_root', lambda: False)():
+                    if not self.branch.repository.supports_rich_root():
+                        raise errors.RootNotRich()
+            if message_callback is None:
+                if message is not None:
+                    if isinstance(message, bytes):
+                        message = message.decode(get_user_encoding())
+
+                    def message_callback(x):
+                        return message
+                else:
+                    raise BzrError("The message or message_callback keyword"
+                                   " parameter is required for commit().")
+
+            self.bound_branch = None
+            self.any_entries_deleted = False
+            if exclude is not None:
+                self.exclude = sorted(
+                    minimum_path_selection(exclude))
+            else:
+                self.exclude = []
+            self.local = local
+            self.master_branch = None
+            self.recursive = recursive
+            self.rev_id = None
+            # self.specific_files is None to indicate no filter, or any iterable to
+            # indicate a filter - [] means no files at all, as per iter_changes.
+            if specific_files is not None:
+                self.specific_files = sorted(
+                    minimum_path_selection(specific_files))
+            else:
+                self.specific_files = None
+
+            self.allow_pointless = allow_pointless
+            self.message_callback = message_callback
+            self.timestamp = timestamp
+            self.timezone = timezone
+            self.committer = committer
+            self.strict = strict
+            self.verbose = verbose
+
+            stack.enter_context(self.work_tree.lock_write())
+            self.parents = self.work_tree.get_parent_ids()
+            self.pb = ui.ui_factory.nested_progress_bar()
+            stack.callback(self.pb.finished)
+            self.basis_revid = self.work_tree.last_revision()
+            self.basis_tree = self.work_tree.basis_tree()
+            stack.enter_context(self.basis_tree.lock_read())
+            # Cannot commit with conflicts present.
+            if len(self.work_tree.conflicts()) > 0:
+                raise ConflictsInTree
+
+            # Setup the bound branch variables as needed.
+            self._check_bound_branch(stack, possible_master_transports)
+            if self.config_stack is None:
+                self.config_stack = self.work_tree.get_config_stack()
+
+            # Check that the working tree is up to date
+            old_revno, old_revid, new_revno = self._check_out_of_date_tree()
+
+            # Complete configuration setup
+            if reporter is not None:
+                self.reporter = reporter
+            elif self.reporter is None:
+                self.reporter = self._select_reporter()
+
+            # Setup the progress bar. As the number of files that need to be
+            # committed in unknown, progress is reported as stages.
+            # We keep track of entries separately though and include that
+            # information in the progress bar during the relevant stages.
+            self.pb_stage_name = ""
+            self.pb_stage_count = 0
+            self.pb_stage_total = 5
             if self.bound_branch:
-                master_location = self.master_branch.base
-            else:
-                master_location = self.branch.base
-
-            # report the start of the commit
-            self.reporter.started(new_revno, self.rev_id, master_location)
-
-            self._update_builder_with_changes()
-            self._check_pointless()
-
-            # TODO: Now the new inventory is known, check for conflicts.
-            # ADHB 2006-08-08: If this is done, populate_new_inv should not add
-            # weave lines, because nothing should be recorded until it is known
-            # that commit will succeed.
-            self._set_progress_stage("Saving data locally")
-            self.builder.finish_inventory()
-
-            # Prompt the user for a commit message if none provided
-            message = message_callback(self)
-            self.message = message
-
-            # Add revision data to the local branch
-            self.rev_id = self.builder.commit(self.message)
-
-        except Exception:
-            mutter("aborting commit write group because of exception:")
-            trace.log_exception_quietly()
-            self.builder.abort()
-            raise
-
-        self._update_branches(old_revno, old_revid, new_revno)
-
-        # 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_paths)
-        self._set_progress_stage("Updating the working tree")
-        self.work_tree.update_basis_by_delta(self.rev_id,
-                                             self.builder.get_basis_delta())
-        self.reporter.completed(new_revno, self.rev_id)
-        self._process_post_hooks(old_revno, new_revno)
-        return self.rev_id
+                # 2 extra stages: "Uploading data to master branch" and "Merging
+                # tags to master branch"
+                self.pb_stage_total += 2
+            self.pb.show_pct = False
+            self.pb.show_spinner = False
+            self.pb.show_eta = False
+            self.pb.show_count = True
+            self.pb.show_bar = True
+
+            # After a merge, a selected file commit is not supported.
+            # See 'bzr help merge' for an explanation as to why.
+            if len(self.parents) > 1 and self.specific_files is not None:
+                raise CannotCommitSelectedFileMerge(self.specific_files)
+            # Excludes are a form of selected file commit.
+            if len(self.parents) > 1 and self.exclude:
+                raise CannotCommitSelectedFileMerge(self.exclude)
+
+            # Collect the changes
+            self._set_progress_stage("Collecting changes", counter=True)
+            self._lossy = lossy
+            self.builder = self.branch.get_commit_builder(
+                self.parents, self.config_stack, timestamp, timezone, committer,
+                self.revprops, rev_id, lossy=lossy)
+
+            if self.builder.updates_branch and self.bound_branch:
+                self.builder.abort()
+                raise AssertionError(
+                    "bound branches not supported for commit builders "
+                    "that update the branch")
+
+            try:
+                # find the location being committed to
+                if self.bound_branch:
+                    master_location = self.master_branch.base
+                else:
+                    master_location = self.branch.base
+
+                # report the start of the commit
+                self.reporter.started(new_revno, self.rev_id, master_location)
+
+                self._update_builder_with_changes()
+                self._check_pointless()
+
+                # TODO: Now the new inventory is known, check for conflicts.
+                # ADHB 2006-08-08: If this is done, populate_new_inv should not add
+                # weave lines, because nothing should be recorded until it is known
+                # that commit will succeed.
+                self._set_progress_stage("Saving data locally")
+                self.builder.finish_inventory()
+
+                # Prompt the user for a commit message if none provided
+                message = message_callback(self)
+                self.message = message
+
+                # Add revision data to the local branch
+                self.rev_id = self.builder.commit(self.message)
+
+            except Exception:
+                mutter("aborting commit write group because of exception:")
+                trace.log_exception_quietly()
+                self.builder.abort()
+                raise
+
+            self._update_branches(old_revno, old_revid, new_revno)
+
+            # 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_paths)
+            self._set_progress_stage("Updating the working tree")
+            self.work_tree.update_basis_by_delta(self.rev_id,
+                                                 self.builder.get_basis_delta())
+            self.reporter.completed(new_revno, self.rev_id)
+            self._process_post_hooks(old_revno, new_revno)
+            return self.rev_id
 
     def _update_branches(self, old_revno, old_revid, new_revno):
         """Update the master and local branch to the new revision.
@@ -537,7 +511,7 @@
             return
         raise PointlessCommit()
 
-    def _check_bound_branch(self, operation, possible_master_transports=None):
+    def _check_bound_branch(self, stack, possible_master_transports=None):
         """Check to see if the local branch is bound.
 
         If it is bound, then most of the commit will actually be
@@ -577,8 +551,7 @@
         # Now things are ready to change the master branch
         # so grab the lock
         self.bound_branch = self.branch
-        self.master_branch.lock_write()
-        operation.add_cleanup(self.master_branch.unlock)
+        stack.enter_context(self.master_branch.lock_write())
 
     def _check_out_of_date_tree(self):
         """Check that the working tree is up to date.

=== modified file 'breezy/diff.py'
--- breezy/diff.py	2019-07-07 18:19:07 +0000
+++ breezy/diff.py	2019-07-27 23:18:50 +0000
@@ -29,6 +29,7 @@
 import tempfile
 
 from breezy import (
+    cleanup,
     controldir,
     errors,
     osutils,
@@ -362,7 +363,7 @@
 
 
 def get_trees_and_branches_to_diff_locked(
-        path_list, revision_specs, old_url, new_url, add_cleanup, apply_view=True):
+        path_list, revision_specs, old_url, new_url, exit_stack, apply_view=True):
     """Get the trees and specific files to diff given a list of paths.
 
     This method works out the trees to be diff'ed and the files of
@@ -379,8 +380,8 @@
     :param new_url:
         The url of the new branch or tree. If None, the tree to use is
         taken from the first path, if any, or the current working tree.
-    :param add_cleanup:
-        a callable like Command.add_cleanup.  get_trees_and_branches_to_diff
+    :param exit_stack:
+        an ExitStack object. get_trees_and_branches_to_diff
         will register cleanups that must be run to unlock the trees, etc.
     :param apply_view:
         if True and a view is set, apply the view or check that the paths
@@ -389,7 +390,7 @@
         a tuple of (old_tree, new_tree, old_branch, new_branch,
         specific_files, extra_trees) where extra_trees is a sequence of
         additional trees to search in for file-ids.  The trees and branches
-        will be read-locked until the cleanups registered via the add_cleanup
+        will be read-locked until the cleanups registered via the exit_stack
         param are run.
     """
     # Get the old and new revision specs
@@ -421,11 +422,9 @@
 
     def lock_tree_or_branch(wt, br):
         if wt is not None:
-            wt.lock_read()
-            add_cleanup(wt.unlock)
+            exit_stack.enter_context(wt.lock_read())
         elif br is not None:
-            br.lock_read()
-            add_cleanup(br.unlock)
+            exit_stack.enter_context(br.lock_read())
 
     # Get the old location
     specific_files = []
@@ -518,23 +517,18 @@
         context = DEFAULT_CONTEXT_AMOUNT
     if format_cls is None:
         format_cls = DiffTree
-    with old_tree.lock_read():
+    with cleanup.ExitStack() as exit_stack:
+        exit_stack.enter_context(old_tree.lock_read())
         if extra_trees is not None:
             for tree in extra_trees:
-                tree.lock_read()
-        new_tree.lock_read()
-        try:
-            differ = format_cls.from_trees_options(old_tree, new_tree, to_file,
-                                                   path_encoding,
-                                                   external_diff_options,
-                                                   old_label, new_label, using,
-                                                   context_lines=context)
-            return differ.show_diff(specific_files, extra_trees)
-        finally:
-            new_tree.unlock()
-            if extra_trees is not None:
-                for tree in extra_trees:
-                    tree.unlock()
+                exit_stack.enter_context(tree.lock_read())
+        exit_stack.enter_context(new_tree.lock_read())
+        differ = format_cls.from_trees_options(old_tree, new_tree, to_file,
+                                               path_encoding,
+                                               external_diff_options,
+                                               old_label, new_label, using,
+                                               context_lines=context)
+        return differ.show_diff(specific_files, extra_trees)
 
 
 def _patch_header_date(tree, path):
@@ -881,12 +875,9 @@
         except OSError as e:
             if e.errno != errno.EEXIST:
                 raise
-        source = tree.get_file(relpath)
-        try:
-            with open(full_path, 'wb') as target:
-                osutils.pumpfile(source, target)
-        finally:
-            source.close()
+        with tree.get_file(relpath) as source, \
+                open(full_path, 'wb') as target:
+            osutils.pumpfile(source, target)
         try:
             mtime = tree.get_file_mtime(relpath)
         except FileTimestampUnavailable:

=== modified file 'breezy/fetch_ghosts.py'
--- breezy/fetch_ghosts.py	2018-05-21 00:30:32 +0000
+++ breezy/fetch_ghosts.py	2019-07-27 23:18:50 +0000
@@ -16,6 +16,7 @@
 
 from __future__ import absolute_import
 
+from . import cleanup
 from .branch import Branch
 from .trace import note
 from .errors import NoSuchRevision, BzrCommandError
@@ -42,14 +43,11 @@
 
     def run(self):
         lock_other = self.this_branch.base != self.other_branch.base
-        with self.this_branch.lock_write():
+        with cleanup.ExitStack() as exit_stack:
+            exit_stack.enter_context(self.this_branch.lock_write())
             if lock_other:
-                self.other_branch.lock_read()
-            try:
-                return self._run_locked()
-            finally:
-                if lock_other:
-                    self.other_branch.unlock()
+                exit_stack.enter_context(self.other_branch.lock_read())
+            return self._run_locked()
 
     def iter_ghosts(self):
         """Find all ancestors that aren't stored in this branch."""

=== modified file 'breezy/git/transportgit.py'
--- breezy/git/transportgit.py	2019-02-06 05:44:37 +0000
+++ breezy/git/transportgit.py	2019-07-27 23:18:50 +0000
@@ -233,11 +233,8 @@
         del self._packed_refs[name]
         if name in self._peeled_refs:
             del self._peeled_refs[name]
-        f = self.transport.open_write_stream("packed-refs")
-        try:
+        with self.transport.open_write_stream("packed-refs") as f:
             write_packed_refs(f, self._packed_refs, self._peeled_refs)
-        finally:
-            f.close()
 
     def set_symbolic_ref(self, name, other):
         """Make a ref point at another ref.
@@ -700,11 +697,8 @@
         p._filename = basename + ".pack"
         f.seek(0)
         self.pack_transport.put_file(basename + ".pack", f)
-        idxfile = self.pack_transport.open_write_stream(basename + ".idx")
-        try:
+        with self.pack_transport.open_write_stream(basename + ".idx") as idxfile:
             write_pack_index_v2(idxfile, entries, p.get_stored_checksum())
-        finally:
-            idxfile.close()
         idxfile = self.pack_transport.get(basename + ".idx")
         idx = load_pack_index_file(basename + ".idx", idxfile)
         final_pack = Pack.from_objects(p, idx)
@@ -729,19 +723,13 @@
 
         pack_sha = p.index.objects_sha1()
 
-        datafile = self.pack_transport.open_write_stream(
-            "pack-%s.pack" % pack_sha.decode('ascii'))
-        try:
+        with self.pack_transport.open_write_stream(
+                "pack-%s.pack" % pack_sha.decode('ascii')) as datafile:
             entries, data_sum = write_pack_objects(datafile, p.pack_tuples())
-        finally:
-            datafile.close()
         entries = sorted([(k, v[0], v[1]) for (k, v) in entries.items()])
-        idxfile = self.pack_transport.open_write_stream(
-            "pack-%s.idx" % pack_sha.decode('ascii'))
-        try:
+        with self.pack_transport.open_write_stream(
+                "pack-%s.idx" % pack_sha.decode('ascii')) as idxfile:
             write_pack_index_v2(idxfile, entries, data_sum)
-        finally:
-            idxfile.close()
 
     def add_pack(self):
         """Add a new pack to this object store.

=== modified file 'breezy/git/unpeel_map.py'
--- breezy/git/unpeel_map.py	2018-11-11 04:08:32 +0000
+++ breezy/git/unpeel_map.py	2019-07-27 23:18:50 +0000
@@ -62,13 +62,10 @@
                 f.write(b"%s: %s\n" % (k, v))
 
     def save_in_repository(self, repository):
-        f = BytesIO()
-        try:
+        with BytesIO() as f:
             self.save(f)
             f.seek(0)
             repository.control_transport.put_file("git-unpeel-map", f)
-        finally:
-            f.close()
 
     def peel_tag(self, git_sha, default=None):
         """Peel a tag."""

=== modified file 'breezy/library_state.py'
--- breezy/library_state.py	2018-11-11 04:08:32 +0000
+++ breezy/library_state.py	2019-07-27 23:18:50 +0000
@@ -44,7 +44,7 @@
     currently always exposed as breezy._global_state, but we desired to move
     to a point where no global state is needed at all.
 
-    :ivar cleanups: An ObjectWithCleanups which can be used for cleanups that
+    :ivar exit_stack: An ExitStack which can be used for cleanups that
         should occur when the use of breezy is completed. This is initialised
         in __enter__ and executed in __exit__.
     """
@@ -89,10 +89,10 @@
         # isolation within the same interpreter.  It's not reached on normal
         # in-process run_bzr calls.  If it's broken, we expect that
         # TestRunBzrSubprocess may fail.
-        self.cleanups = cleanup.ObjectWithCleanups()
+        self.exit_stack = cleanup.ExitStack()
 
         if breezy.version_info[3] == 'final':
-            self.cleanups.add_cleanup(
+            self.exit_stack.callback(
                 symbol_versioning.suppress_deprecation_warnings(override=True))
 
         self._trace.__enter__()
@@ -111,7 +111,7 @@
             # Save config changes
             for k, store in self.config_stores.items():
                 store.save_changes()
-        self.cleanups.cleanup_now()
+        self.exit_stack.close()
         trace._flush_stdout_stderr()
         trace._flush_trace()
         osutils.report_extension_load_failures()

=== modified file 'breezy/log.py'
--- breezy/log.py	2019-06-16 02:07:41 +0000
+++ breezy/log.py	2019-07-27 23:18:50 +0000
@@ -2038,7 +2038,7 @@
         lf.log_revision(lr)
 
 
-def _get_info_for_log_files(revisionspec_list, file_list, add_cleanup):
+def _get_info_for_log_files(revisionspec_list, file_list, exit_stack):
     """Find file-ids and kinds given a list of files and a revision range.
 
     We search for files at the end of the range. If not found there,
@@ -2048,8 +2048,8 @@
     :param file_list: the list of paths given on the command line;
       the first of these can be a branch location or a file path,
       the remainder must be file paths
-    :param add_cleanup: When the branch returned is read locked,
-      an unlock call will be queued to the cleanup.
+    :param exit_stack: When the branch returned is read locked,
+      an unlock call will be queued to the exit stack.
     :return: (branch, info_list, start_rev_info, end_rev_info) where
       info_list is a list of (relative_path, file_id, kind) tuples where
       kind is one of values 'directory', 'file', 'symlink', 'tree-reference'.
@@ -2058,7 +2058,7 @@
     from breezy.builtins import _get_revision_range
     tree, b, path = controldir.ControlDir.open_containing_tree_or_branch(
         file_list[0])
-    add_cleanup(b.lock_read().unlock)
+    exit_stack.enter_context(b.lock_read())
     # XXX: It's damn messy converting a list of paths to relative paths when
     # those paths might be deleted ones, they might be on a case-insensitive
     # filesystem and/or they might be in silly locations (like another branch).

=== modified file 'breezy/mail_client.py'
--- breezy/mail_client.py	2018-11-12 01:41:38 +0000
+++ breezy/mail_client.py	2019-07-27 23:18:50 +0000
@@ -172,11 +172,8 @@
             basename = 'attachment'
         pathname = osutils.mkdtemp(prefix='bzr-mail-')
         attach_path = osutils.pathjoin(pathname, basename + extension)
-        outfile = open(attach_path, 'wb')
-        try:
+        with open(attach_path, 'wb') as outfile:
             outfile.write(attachment)
-        finally:
-            outfile.close()
         if body is not None:
             kwargs = {'body': body}
         else:

=== modified file 'breezy/merge.py'
--- breezy/merge.py	2019-06-29 13:16:26 +0000
+++ breezy/merge.py	2019-07-27 23:18:50 +0000
@@ -447,18 +447,16 @@
     def _add_parent(self):
         new_parents = self.this_tree.get_parent_ids() + [self.other_rev_id]
         new_parent_trees = []
-        operation = cleanup.OperationWithCleanups(
-            self.this_tree.set_parent_trees)
-        for revision_id in new_parents:
-            try:
-                tree = self.revision_tree(revision_id)
-            except errors.NoSuchRevision:
-                tree = None
-            else:
-                tree.lock_read()
-                operation.add_cleanup(tree.unlock)
-            new_parent_trees.append((revision_id, tree))
-        operation.run_simple(new_parent_trees, allow_leftmost_as_ghost=True)
+        with cleanup.ExitStack() as stack:
+            for revision_id in new_parents:
+                try:
+                    tree = self.revision_tree(revision_id)
+                except errors.NoSuchRevision:
+                    tree = None
+                else:
+                    stack.enter_context(tree.lock_read())
+                new_parent_trees.append((revision_id, tree))
+            self.this_tree.set_parent_trees(new_parent_trees, allow_leftmost_as_ghost=True)
 
     def set_other(self, other_revision, possible_transports=None):
         """Set the revision and tree to merge from.
@@ -656,16 +654,13 @@
         return merge
 
     def do_merge(self):
-        operation = cleanup.OperationWithCleanups(self._do_merge_to)
-        self.this_tree.lock_tree_write()
-        operation.add_cleanup(self.this_tree.unlock)
-        if self.base_tree is not None:
-            self.base_tree.lock_read()
-            operation.add_cleanup(self.base_tree.unlock)
-        if self.other_tree is not None:
-            self.other_tree.lock_read()
-            operation.add_cleanup(self.other_tree.unlock)
-        merge = operation.run_simple()
+        with cleanup.ExitStack() as stack:
+            stack.enter_context(self.this_tree.lock_tree_write())
+            if self.base_tree is not None:
+                stack.enter_context(self.base_tree.lock_read())
+            if self.other_tree is not None:
+                stack.enter_context(self.other_tree.lock_read())
+            merge = self._do_merge_to()
         if len(merge.cooked_conflicts) == 0:
             if not self.ignore_zero and not trace.is_quiet():
                 trace.note(gettext("All changes applied successfully."))
@@ -759,27 +754,20 @@
             self.do_merge()
 
     def do_merge(self):
-        operation = cleanup.OperationWithCleanups(self._do_merge)
-        self.working_tree.lock_tree_write()
-        operation.add_cleanup(self.working_tree.unlock)
-        self.this_tree.lock_read()
-        operation.add_cleanup(self.this_tree.unlock)
-        self.base_tree.lock_read()
-        operation.add_cleanup(self.base_tree.unlock)
-        self.other_tree.lock_read()
-        operation.add_cleanup(self.other_tree.unlock)
-        operation.run()
-
-    def _do_merge(self, operation):
-        self.tt = self.working_tree.get_transform()
-        operation.add_cleanup(self.tt.finalize)
-        self._compute_transform()
-        results = self.tt.apply(no_conflicts=True)
-        self.write_modified(results)
-        try:
-            self.working_tree.add_conflicts(self.cooked_conflicts)
-        except errors.UnsupportedOperation:
-            pass
+        with cleanup.ExitStack() as stack:
+            stack.enter_context(self.working_tree.lock_tree_write())
+            stack.enter_context(self.this_tree.lock_read())
+            stack.enter_context(self.base_tree.lock_read())
+            stack.enter_context(self.other_tree.lock_read())
+            self.tt = self.working_tree.get_transform()
+            stack.enter_context(self.tt)
+            self._compute_transform()
+            results = self.tt.apply(no_conflicts=True)
+            self.write_modified(results)
+            try:
+                self.working_tree.add_conflicts(self.cooked_conflicts)
+            except errors.UnsupportedOperation:
+                pass
 
     def make_preview_transform(self):
         with self.base_tree.lock_read(), self.other_tree.lock_read():

=== modified file 'breezy/merge_directive.py'
--- breezy/merge_directive.py	2019-06-30 10:50:40 +0000
+++ breezy/merge_directive.py	2019-07-27 23:18:50 +0000
@@ -23,6 +23,7 @@
 lazy_import.lazy_import(globals(), """
 from breezy import (
     branch as _mod_branch,
+    cleanup,
     diff,
     email_message,
     errors,
@@ -596,10 +597,8 @@
         If the message is not supplied, the message from revision_id will be
         used for the commit.
         """
-        locked = []
-        try:
-            repository.lock_write()
-            locked.append(repository)
+        with cleanup.ExitStack() as exit_stack:
+            exit_stack.enter_context(repository.lock_write())
             t_revision_id = revision_id
             if revision_id == b'null:':
                 t_revision_id = None
@@ -609,8 +608,7 @@
                 submit_branch = _mod_branch.Branch.open(target_branch)
             else:
                 submit_branch = local_target_branch
-            submit_branch.lock_read()
-            locked.append(submit_branch)
+            exit_stack.enter_context(submit_branch.lock_read())
             if submit_branch.get_public_branch() is not None:
                 target_branch = submit_branch.get_public_branch()
             submit_revision_id = submit_branch.last_revision()
@@ -636,16 +634,12 @@
 
             if public_branch is not None and not include_bundle:
                 public_branch_obj = _mod_branch.Branch.open(public_branch)
-                public_branch_obj.lock_read()
-                locked.append(public_branch_obj)
+                exit_stack.enter_context(public_branch_obj.lock_read())
                 if not public_branch_obj.repository.has_revision(
                         revision_id):
                     raise errors.PublicBranchOutOfDate(public_branch,
                                                        revision_id)
             testament_sha1 = t.as_sha1()
-        finally:
-            for entry in reversed(locked):
-                entry.unlock()
         return klass(revision_id, testament_sha1, time, timezone,
                      target_branch, patch, public_branch, message, bundle,
                      base_revision_id)

=== modified file 'breezy/missing.py'
--- breezy/missing.py	2018-11-12 01:41:38 +0000
+++ breezy/missing.py	2019-07-27 23:18:50 +0000
@@ -63,19 +63,12 @@
     """
     if include_merged is None:
         include_merged = False
-    local_branch.lock_read()
-    try:
-        remote_branch.lock_read()
-        try:
-            return _find_unmerged(
-                local_branch, remote_branch, restrict=restrict,
-                include_merged=include_merged, backward=backward,
-                local_revid_range=local_revid_range,
-                remote_revid_range=remote_revid_range)
-        finally:
-            remote_branch.unlock()
-    finally:
-        local_branch.unlock()
+    with local_branch.lock_read(), remote_branch.lock_read():
+        return _find_unmerged(
+            local_branch, remote_branch, restrict=restrict,
+            include_merged=include_merged, backward=backward,
+            local_revid_range=local_revid_range,
+            remote_revid_range=remote_revid_range)
 
 
 def _enumerate_mainline(ancestry, graph, tip_revno, tip, backward=True):

=== modified file 'breezy/plugins/email/emailer.py'
--- breezy/plugins/email/emailer.py	2018-11-17 16:53:10 +0000
+++ breezy/plugins/email/emailer.py	2019-07-27 23:18:50 +0000
@@ -213,8 +213,7 @@
         """Spawn a 'mail' subprocess to send the email."""
         # TODO think up a good test for this, but I think it needs
         # a custom binary shipped with. RBC 20051021
-        msgfile = tempfile.NamedTemporaryFile()
-        try:
+        with tempfile.NamedTemporaryFile() as msgfile:
             msgfile.write(self.body().encode('utf8'))
             diff = self.get_diff()
             if diff:
@@ -229,8 +228,6 @@
             if rc != 0:
                 raise errors.BzrError(
                     "Failed to send email: exit status %s" % (rc,))
-        finally:
-            msgfile.close()
 
     def _send_using_smtplib(self):
         """Use python's smtplib to send the email."""

=== modified file 'breezy/plugins/upload/cmds.py'
--- breezy/plugins/upload/cmds.py	2019-02-02 15:13:30 +0000
+++ breezy/plugins/upload/cmds.py	2019-07-27 23:18:50 +0000
@@ -503,12 +503,10 @@
              directory)
 
         if wt:
-            wt.lock_read()
             locked = wt
         else:
-            branch.lock_read()
             locked = branch
-        try:
+        with locked.lock_read():
             if wt:
                 changes = wt.changes_from(wt.basis_tree())
 
@@ -566,8 +564,6 @@
                 uploader.upload_full_tree()
             else:
                 uploader.upload_tree()
-        finally:
-            locked.unlock()
 
         # We uploaded successfully, remember it
         with branch.lock_write():

=== modified file 'breezy/plugins/weave_fmt/bzrdir.py'
--- breezy/plugins/weave_fmt/bzrdir.py	2018-11-11 04:08:32 +0000
+++ breezy/plugins/weave_fmt/bzrdir.py	2019-07-27 23:18:50 +0000
@@ -381,11 +381,8 @@
             self.revisions[rev_id] = rev
 
     def _load_old_inventory(self, rev_id):
-        f = self.branch.repository.inventory_store.get(rev_id)
-        try:
+        with self.branch.repository.inventory_store.get(rev_id) as f:
             old_inv_xml = f.read()
-        finally:
-            f.close()
         inv = xml4.serializer_v4.read_inventory_from_string(old_inv_xml)
         inv.revision_id = rev_id
         rev = self.revisions[rev_id]
@@ -467,11 +464,8 @@
                 ie.revision = previous_ie.revision
                 return
         if ie.has_text():
-            f = self.branch.repository._text_store.get(ie.text_id)
-            try:
+            with self.branch.repository._text_store.get(ie.text_id) as f:
                 file_lines = f.readlines()
-            finally:
-                f.close()
             w.add_lines(rev_id, previous_revisions, file_lines)
             self.text_count += 1
         else:

=== modified file 'breezy/plugins/weave_fmt/test_repository.py'
--- breezy/plugins/weave_fmt/test_repository.py	2018-12-18 20:55:37 +0000
+++ breezy/plugins/weave_fmt/test_repository.py	2019-07-27 23:18:50 +0000
@@ -199,12 +199,8 @@
         # TODO: Should check there is a 'lock' toplevel directory,
         # regardless of contents
         self.assertFalse(t.has('lock/held/info'))
-        repo.lock_write()
-        try:
+        with repo.lock_write():
             self.assertTrue(t.has('lock/held/info'))
-        finally:
-            # unlock so we don't get a warning about failing to do so
-            repo.unlock()
 
     def test_uses_lockdir(self):
         """repo format 7 actually locks on lockdir"""

=== modified file 'breezy/plugins/weave_fmt/workingtree.py'
--- breezy/plugins/weave_fmt/workingtree.py	2019-06-29 13:16:26 +0000
+++ breezy/plugins/weave_fmt/workingtree.py	2019-07-27 23:18:50 +0000
@@ -97,11 +97,8 @@
             branch = a_controldir.open_branch()
         if revision_id is None:
             revision_id = _mod_revision.ensure_null(branch.last_revision())
-        branch.lock_write()
-        try:
+        with branch.lock_write():
             branch.generate_revision_history(revision_id)
-        finally:
-            branch.unlock()
         inv = inventory.Inventory()
         wt = WorkingTree2(a_controldir.root_transport.local_abspath('.'),
                           branch,

=== modified file 'breezy/push.py'
--- breezy/push.py	2019-02-14 22:08:09 +0000
+++ breezy/push.py	2019-07-27 23:18:50 +0000
@@ -169,10 +169,7 @@
     push_result.report(to_file)
     if verbose:
         br_to = push_result.target_branch
-        br_to.lock_read()
-        try:
+        with br_to.lock_read():
             from .log import show_branch_change
             show_branch_change(br_to, to_file, push_result.old_revno,
                                push_result.old_revid)
-        finally:
-            br_to.unlock()

=== modified file 'breezy/reconfigure.py'
--- breezy/reconfigure.py	2018-11-11 04:08:32 +0000
+++ breezy/reconfigure.py	2019-07-27 23:18:50 +0000
@@ -119,30 +119,24 @@
         # a path relative to itself...
         on_url = urlutils.relative_url(branch.base,
                                        urlutils.normalize_url(stacked_on_url))
-        branch.lock_write()
-        try:
+        with branch.lock_write():
             branch.set_stacked_on_url(on_url)
             if not trace.is_quiet():
                 ui.ui_factory.note(gettext(
                     "{0} is now stacked on {1}\n").format(
                     branch.base, branch.get_stacked_on_url()))
-        finally:
-            branch.unlock()
 
 
 class ReconfigureUnstacked(object):
 
     def apply(self, controldir):
         branch = controldir.open_branch()
-        branch.lock_write()
-        try:
+        with branch.lock_write():
             branch.set_stacked_on_url(None)
             if not trace.is_quiet():
                 ui.ui_factory.note(gettext(
                     "%s is now not stacked\n")
                     % (branch.base,))
-        finally:
-            branch.unlock()
 
 
 class Reconfigure(object):

=== modified file 'breezy/repository.py'
--- breezy/repository.py	2019-07-25 22:37:25 +0000
+++ breezy/repository.py	2019-07-27 23:18:50 +0000
@@ -1598,12 +1598,9 @@
             pb.update(gettext('Creating new repository'))
             converted = self.target_format.initialize(self.repo_dir,
                                                       self.source_repo.is_shared())
-            converted.lock_write()
-            try:
+            with converted.lock_write():
                 pb.update(gettext('Copying content'))
                 self.source_repo.copy_content_into(converted)
-            finally:
-                converted.unlock()
             pb.update(gettext('Deleting old repository content'))
             self.repo_dir.transport.delete_tree('repository.backup')
             ui.ui_factory.note(gettext('repository converted'))

=== modified file 'breezy/revisionspec.py'
--- breezy/revisionspec.py	2019-02-26 08:09:10 +0000
+++ breezy/revisionspec.py	2019-07-27 23:18:50 +0000
@@ -579,11 +579,8 @@
             raise errors.InvalidRevisionSpec(self.user_spec, context_branch,
                                              'cannot go before the null: revision')
         context_repo = context_branch.repository
-        context_repo.lock_read()
-        try:
+        with context_repo.lock_read():
             parent_map = context_repo.get_parent_map([base_revision_id])
-        finally:
-            context_repo.unlock()
         if base_revision_id not in parent_map:
             # Ghost, or unknown revision id
             raise errors.InvalidRevisionSpec(self.user_spec, context_branch,

=== modified file 'breezy/send.py'
--- breezy/send.py	2018-11-11 04:08:32 +0000
+++ breezy/send.py	2019-07-27 23:18:50 +0000
@@ -46,8 +46,7 @@
         from_, possible_transports=possible_transports)[:2]
     # we may need to write data into branch's repository to calculate
     # the data to send.
-    branch.lock_write()
-    try:
+    with branch.lock_write():
         if output is None:
             config_stack = branch.get_config_stack()
             if mail_to is None:
@@ -143,11 +142,8 @@
                     os.mkdir(output, 0o755)
                 for (filename, lines) in directive.to_files():
                     path = os.path.join(output, filename)
-                    outfile = open(path, 'wb')
-                    try:
+                    with open(path, 'wb') as outfile:
                         outfile.writelines(lines)
-                    finally:
-                        outfile.close()
             else:
                 if output == '-':
                     outfile = to_file
@@ -158,8 +154,6 @@
                 finally:
                     if outfile is not to_file:
                         outfile.close()
-    finally:
-        branch.unlock()
 
 
 def _send_4(branch, revision_id, target_branch, public_branch,

=== modified file 'breezy/shelf_ui.py'
--- breezy/shelf_ui.py	2019-03-02 21:46:18 +0000
+++ breezy/shelf_ui.py	2019-07-27 23:18:50 +0000
@@ -25,6 +25,7 @@
 
 from . import (
     builtins,
+    cleanup,
     delta,
     diff,
     errors,
@@ -178,15 +179,12 @@
         tree, path = workingtree.WorkingTree.open_containing(directory)
         # Ensure that tree is locked for the lifetime of target_tree, as
         # target tree may be reading from the same dirstate.
-        tree.lock_tree_write()
-        try:
+        with tree.lock_tree_write():
             target_tree = builtins._get_one_revision_tree('shelf2', revision,
                                                           tree.branch, tree)
             files = tree.safe_relpath_files(file_list)
             return klass(tree, target_tree, diff_writer, all, all, files,
                          message, destroy)
-        finally:
-            tree.unlock()
 
     def run(self):
         """Interactively shelve the changes."""
@@ -460,14 +458,13 @@
 
     def run(self):
         """Perform the unshelving operation."""
-        self.tree.lock_tree_write()
-        cleanups = [self.tree.unlock]
-        try:
+        with cleanup.ExitStack() as exit_stack:
+            exit_stack.enter_context(self.tree.lock_tree_write())
             if self.read_shelf:
                 trace.note(gettext('Using changes with id "%d".') %
                            self.shelf_id)
                 unshelver = self.manager.get_unshelver(self.shelf_id)
-                cleanups.append(unshelver.finalize)
+                exit_stack.callback(unshelver.finalize)
                 if unshelver.message is not None:
                     trace.note(gettext('Message: %s') % unshelver.message)
                 change_reporter = delta._ChangeReporter()
@@ -483,9 +480,6 @@
                 self.manager.delete_shelf(self.shelf_id)
                 trace.note(gettext('Deleted changes with id "%d".') %
                            self.shelf_id)
-        finally:
-            for cleanup in reversed(cleanups):
-                cleanup()
 
     def write_diff(self, merger):
         """Write this operation's diff to self.write_diff_to."""

=== modified file 'breezy/tag.py'
--- breezy/tag.py	2019-02-02 17:52:28 +0000
+++ breezy/tag.py	2019-07-27 23:18:50 +0000
@@ -283,49 +283,45 @@
             (tagname, source_target, dest_target), or None if no copying was
             done.
         """
-        operation = cleanup.OperationWithCleanups(self._merge_to_operation)
-        return operation.run(to_tags, overwrite, ignore_master)
-
-    def _merge_to_operation(self, operation, to_tags, overwrite, ignore_master):
-        add_cleanup = operation.add_cleanup
-        if self.branch == to_tags.branch:
-            return {}, []
-        if not self.branch.supports_tags():
-            # obviously nothing to copy
-            return {}, []
-        source_dict = self.get_tag_dict()
-        if not source_dict:
-            # no tags in the source, and we don't want to clobber anything
-            # that's in the destination
-            return {}, []
-        # We merge_to both master and child individually.
-        #
-        # It's possible for master and child to have differing sets of
-        # tags, in which case it's possible to have different sets of
-        # conflicts.  We report the union of both conflict sets.  In
-        # that case it's likely the child and master have accepted
-        # different tags from the source, which may be a surprising result, but
-        # the best we can do in the circumstances.
-        #
-        # Ideally we'd improve this API to report the different conflicts
-        # more clearly to the caller, but we don't want to break plugins
-        # such as bzr-builddeb that use this API.
-        add_cleanup(to_tags.branch.lock_write().unlock)
-        if ignore_master:
-            master = None
-        else:
-            master = to_tags.branch.get_master_branch()
-        if master is not None:
-            add_cleanup(master.lock_write().unlock)
-        updates, conflicts = self._merge_to(to_tags, source_dict, overwrite)
-        if master is not None:
-            extra_updates, extra_conflicts = self._merge_to(master.tags,
-                                                            source_dict, overwrite)
-            updates.update(extra_updates)
-            conflicts += extra_conflicts
-        # We use set() to remove any duplicate conflicts from the master
-        # branch.
-        return updates, set(conflicts)
+        with cleanup.ExitStack() as stack:
+            if self.branch == to_tags.branch:
+                return {}, []
+            if not self.branch.supports_tags():
+                # obviously nothing to copy
+                return {}, []
+            source_dict = self.get_tag_dict()
+            if not source_dict:
+                # no tags in the source, and we don't want to clobber anything
+                # that's in the destination
+                return {}, []
+            # We merge_to both master and child individually.
+            #
+            # It's possible for master and child to have differing sets of
+            # tags, in which case it's possible to have different sets of
+            # conflicts.  We report the union of both conflict sets.  In
+            # that case it's likely the child and master have accepted
+            # different tags from the source, which may be a surprising result, but
+            # the best we can do in the circumstances.
+            #
+            # Ideally we'd improve this API to report the different conflicts
+            # more clearly to the caller, but we don't want to break plugins
+            # such as bzr-builddeb that use this API.
+            stack.enter_context(to_tags.branch.lock_write())
+            if ignore_master:
+                master = None
+            else:
+                master = to_tags.branch.get_master_branch()
+            if master is not None:
+                stack.enter_context(master.lock_write())
+            updates, conflicts = self._merge_to(to_tags, source_dict, overwrite)
+            if master is not None:
+                extra_updates, extra_conflicts = self._merge_to(master.tags,
+                                                                source_dict, overwrite)
+                updates.update(extra_updates)
+                conflicts += extra_conflicts
+            # We use set() to remove any duplicate conflicts from the master
+            # branch.
+            return updates, set(conflicts)
 
     def _merge_to(self, to_tags, source_dict, overwrite):
         dest_dict = to_tags.get_tag_dict()

=== modified file 'breezy/tests/blackbox/test_commit.py'
--- breezy/tests/blackbox/test_commit.py	2019-06-16 17:36:59 +0000
+++ breezy/tests/blackbox/test_commit.py	2019-07-27 23:18:50 +0000
@@ -316,9 +316,8 @@
         this_tree.commit('create_files')
         other_dir = this_tree.controldir.sprout('other')
         other_tree = other_dir.open_workingtree()
-        other_tree.lock_write()
-        # perform the needed actions on the files and dirs.
-        try:
+        with other_tree.lock_write():
+            # perform the needed actions on the files and dirs.
             other_tree.rename_one('dirtorename', 'renameddir')
             other_tree.rename_one('dirtoreparent', 'renameddir/reparenteddir')
             other_tree.rename_one('filetorename', 'renamedfile')
@@ -332,8 +331,6 @@
             other_tree.add('newfile')
             other_tree.add('newdir/')
             other_tree.commit('modify all sample files and dirs.')
-        finally:
-            other_tree.unlock()
         this_tree.merge_from_branch(other_tree.branch)
         out, err = self.run_bzr('commit -m added', working_dir='this')
         self.assertEqual('', out)

=== modified file 'breezy/tests/blackbox/test_export.py'
--- breezy/tests/blackbox/test_export.py	2019-01-13 18:33:39 +0000
+++ breezy/tests/blackbox/test_export.py	2019-07-27 23:18:50 +0000
@@ -304,12 +304,9 @@
 
         self.run_bzr('export ../first.tar -r 1')
         self.assertTrue(os.path.isfile('../first.tar'))
-        tf = tarfile.open('../first.tar')
-        try:
+        with tarfile.open('../first.tar') as tf:
             self.assertEqual(['first/hello'], sorted(tf.getnames()))
             self.assertEqual(b'foo', tf.extractfile('first/hello').read())
-        finally:
-            tf.close()
 
         self.run_bzr('export ../first.tar.gz -r 1')
         self.assertTrue(os.path.isfile('../first.tar.gz'))
@@ -320,19 +317,13 @@
         self.run_bzr('export ../first.tar.tbz2 -r 1')
         self.assertTrue(os.path.isfile('../first.tar.tbz2'))
 
-        tf = tarfile.open('../first.tar.tbz2', 'r:bz2')
-        try:
+        with tarfile.open('../first.tar.tbz2', 'r:bz2') as tf:
             self.assertEqual(['first.tar/hello'], sorted(tf.getnames()))
             self.assertEqual(b'foo', tf.extractfile('first.tar/hello').read())
-        finally:
-            tf.close()
         self.run_bzr('export ../first2.tar -r 1 --root pizza')
-        tf = tarfile.open('../first2.tar')
-        try:
+        with tarfile.open('../first2.tar') as tf:
             self.assertEqual(['pizza/hello'], sorted(tf.getnames()))
             self.assertEqual(b'foo', tf.extractfile('pizza/hello').read())
-        finally:
-            tf.close()
 
     def test_basic_zipfile_export(self):
         self.example_branch()
@@ -340,28 +331,19 @@
 
         self.run_bzr('export ../first.zip -r 1')
         self.assertPathExists('../first.zip')
-        zf = zipfile.ZipFile('../first.zip')
-        try:
+        with zipfile.ZipFile('../first.zip') as zf:
             self.assertEqual(['first/hello'], sorted(zf.namelist()))
             self.assertEqual(b'foo', zf.read('first/hello'))
-        finally:
-            zf.close()
 
         self.run_bzr('export ../first2.zip -r 1 --root pizza')
-        zf = zipfile.ZipFile('../first2.zip')
-        try:
+        with zipfile.ZipFile('../first2.zip') as zf:
             self.assertEqual(['pizza/hello'], sorted(zf.namelist()))
             self.assertEqual(b'foo', zf.read('pizza/hello'))
-        finally:
-            zf.close()
 
         self.run_bzr('export ../first-zip --format=zip -r 1')
-        zf = zipfile.ZipFile('../first-zip')
-        try:
+        with zipfile.ZipFile('../first-zip') as zf:
             self.assertEqual(['first-zip/hello'], sorted(zf.namelist()))
             self.assertEqual(b'foo', zf.read('first-zip/hello'))
-        finally:
-            zf.close()
 
     def test_export_from_outside_branch(self):
         self.example_branch()

=== modified file 'breezy/tests/blackbox/test_info.py'
--- breezy/tests/blackbox/test_info.py	2018-11-28 03:07:45 +0000
+++ breezy/tests/blackbox/test_info.py	2019-07-27 23:18:50 +0000
@@ -1399,83 +1399,53 @@
                                         repo_branch=repo_branch,
                                         verbose=True, light_checkout=True)
         # U U L
-        lco_tree.branch.repository.lock_write()
-        try:
+        with lco_tree.branch.repository.lock_write():
             self.assertCheckoutStatusOutput('-v tree/lightcheckout',
                                             lco_tree, repo_branch=repo_branch,
                                             repo_locked=True, verbose=True, light_checkout=True)
-        finally:
-            lco_tree.branch.repository.unlock()
         # U L L
-        lco_tree.branch.lock_write()
-        try:
+        with lco_tree.branch.lock_write():
             self.assertCheckoutStatusOutput('-v tree/lightcheckout',
                                             lco_tree,
                                             branch_locked=True,
                                             repo_locked=True,
                                             repo_branch=repo_branch,
                                             verbose=True)
-        finally:
-            lco_tree.branch.unlock()
         # L L L
-        lco_tree.lock_write()
-        try:
+        with lco_tree.lock_write():
             self.assertCheckoutStatusOutput('-v tree/lightcheckout',
                                             lco_tree, repo_branch=repo_branch,
                                             tree_locked=True,
                                             branch_locked=True,
                                             repo_locked=True,
                                             verbose=True)
-        finally:
-            lco_tree.unlock()
         # L L U
-        lco_tree.lock_write()
-        lco_tree.branch.repository.unlock()
-        try:
+        with lco_tree.lock_write(), lco_tree.branch.repository.unlock():
             self.assertCheckoutStatusOutput('-v tree/lightcheckout',
                                             lco_tree, repo_branch=repo_branch,
                                             tree_locked=True,
                                             branch_locked=True,
                                             verbose=True)
-        finally:
-            lco_tree.branch.repository.lock_write()
-            lco_tree.unlock()
         # L U U
-        lco_tree.lock_write()
-        lco_tree.branch.unlock()
-        try:
+        with lco_tree.lock_write(), lco_tree.branch.unlock():
             self.assertCheckoutStatusOutput('-v tree/lightcheckout',
                                             lco_tree, repo_branch=repo_branch,
                                             tree_locked=True,
                                             verbose=True)
-        finally:
-            lco_tree.branch.lock_write()
-            lco_tree.unlock()
         # L U L
-        lco_tree.lock_write()
-        lco_tree.branch.unlock()
-        lco_tree.branch.repository.lock_write()
-        try:
+        with lco_tree.lock_write(), lco_tree.branch.unlock(), \
+                lco_tree.branch.repository.lock_write():
             self.assertCheckoutStatusOutput('-v tree/lightcheckout',
                                             lco_tree, repo_branch=repo_branch,
                                             tree_locked=True,
                                             repo_locked=True,
                                             verbose=True)
-        finally:
-            lco_tree.branch.repository.unlock()
-            lco_tree.branch.lock_write()
-            lco_tree.unlock()
         # U L U
-        lco_tree.branch.lock_write()
-        lco_tree.branch.repository.unlock()
-        try:
+        with lco_tree.branch.lock_write(), lco_tree.branch.repository.unlock():
             self.assertCheckoutStatusOutput('-v tree/lightcheckout',
                                             lco_tree, repo_branch=repo_branch,
                                             branch_locked=True,
                                             verbose=True)
-        finally:
-            lco_tree.branch.repository.lock_write()
-            lco_tree.branch.unlock()
 
         if sys.platform == 'win32':
             self.knownFailure('Win32 cannot run "brz info"'

=== modified file 'breezy/tests/blackbox/test_logformats.py'
--- breezy/tests/blackbox/test_logformats.py	2019-06-16 01:03:51 +0000
+++ breezy/tests/blackbox/test_logformats.py	2019-07-27 23:18:50 +0000
@@ -41,14 +41,11 @@
             self.fail("%s exists" % conf_path)
 
         bedding.ensure_config_dir_exists()
-        f = open(conf_path, 'wb')
-        try:
+        with open(conf_path, 'wb') as f:
             f.write(b"""[DEFAULT]
 email=Joe Foo <[e-mail]>
 log_format=line
 """)
-        finally:
-            f.close()
 
     def _make_simple_branch(self, relpath='.'):
         wt = self.make_branch_and_tree(relpath)

=== modified file 'breezy/tests/blackbox/test_remove.py'
--- breezy/tests/blackbox/test_remove.py	2019-03-05 09:17:49 +0000
+++ breezy/tests/blackbox/test_remove.py	2019-07-27 23:18:50 +0000
@@ -40,14 +40,11 @@
 
     def _make_tree_and_add(self, paths):
         tree = self.make_branch_and_tree('.')
-        tree.lock_write()
-        try:
+        with tree.lock_write():
             self.build_tree(paths)
             for path in paths:
                 file_id = path.replace('/', '_').encode('utf-8') + _id
                 tree.add(path, file_id)
-        finally:
-            tree.unlock()
         return tree
 
     def assertFilesDeleted(self, files):

=== modified file 'breezy/tests/blackbox/test_status.py'
--- breezy/tests/blackbox/test_status.py	2018-11-11 04:08:32 +0000
+++ breezy/tests/blackbox/test_status.py	2019-07-27 23:18:50 +0000
@@ -497,15 +497,11 @@
         """Simulate status of out-of-date tree after remote push"""
         tree = self.make_branch_and_tree('.')
         self.build_tree_contents([('a', b'foo\n')])
-        tree.lock_write()
-        try:
+        with tree.lock_write():
             tree.add(['a'])
             tree.commit('add test file')
             # simulate what happens after a remote push
             tree.set_last_revision(b"0")
-        finally:
-            # before run another commands we should unlock tree
-            tree.unlock()
         out, err = self.run_bzr('status')
         self.assertEqual("working tree is out of date, run 'brz update'\n",
                          err)

=== modified file 'breezy/tests/per_branch/test_get_revision_id_to_revno_map.py'
--- breezy/tests/per_branch/test_get_revision_id_to_revno_map.py	2018-11-11 04:08:32 +0000
+++ breezy/tests/per_branch/test_get_revision_id_to_revno_map.py	2019-07-27 23:18:50 +0000
@@ -76,18 +76,14 @@
         """
         branch, revmap, calls = self.get_instrumented_branch()
         # Lock the branch, then repeatedly call revision_history.
-        branch.lock_read()
-        try:
+        with branch.lock_read():
             branch.get_revision_id_to_revno_map()
             self.assertEqual(['_gen_revno_map'], calls)
-        finally:
-            branch.unlock()
 
     def test_set_last_revision_info_when_locked(self):
         """Calling set_last_revision_info should reset the cache."""
         branch, revmap, calls = self.get_instrumented_branch()
-        branch.lock_write()
-        try:
+        with branch.lock_write():
             self.assertEqual({revmap['1']: (1,),
                               revmap['2']: (2, ),
                               revmap['3']: (3, ),
@@ -100,5 +96,3 @@
             self.assertEqual({revmap['1']: (1, ), revmap['2']: (2, )},
                              branch.get_revision_id_to_revno_map())
             self.assertEqual(['_gen_revno_map'] * 2, calls)
-        finally:
-            branch.unlock()

=== modified file 'breezy/tests/per_branch/test_push.py'
--- breezy/tests/per_branch/test_push.py	2018-11-12 01:41:38 +0000
+++ breezy/tests/per_branch/test_push.py	2019-07-27 23:18:50 +0000
@@ -141,16 +141,9 @@
         source.add(['a'])
         source.commit('a')
 
-        source.branch.lock_read()
-        try:
-            target.lock_write()
-            try:
-                source.branch.push(
-                    target, stop_revision=source.last_revision())
-            finally:
-                target.unlock()
-        finally:
-            source.branch.unlock()
+        with source.branch.lock_read(), target.lock_write():
+            source.branch.push(
+                target, stop_revision=source.last_revision())
 
     def test_push_within_repository(self):
         """Push from one branch to another inside the same repository."""

=== modified file 'breezy/tests/per_branch/test_stacking.py'
--- breezy/tests/per_branch/test_stacking.py	2018-11-11 04:08:32 +0000
+++ breezy/tests/per_branch/test_stacking.py	2019-07-27 23:18:50 +0000
@@ -38,12 +38,9 @@
     def check_lines_added_or_present(self, stacked_branch, revid):
         # similar to a failure seen in bug 288751 by mbp 20081120
         stacked_repo = stacked_branch.repository
-        stacked_repo.lock_read()
-        try:
+        with stacked_repo.lock_read():
             list(stacked_repo.inventories.iter_lines_added_or_present_in_keys(
                 [(revid,)]))
-        finally:
-            stacked_repo.unlock()
 
     def test_get_set_stacked_on_url(self):
         # branches must either:
@@ -134,12 +131,9 @@
         # reading the graph from the stacked branch's repository should see
         # data from the stacked-on branch
         new_repo = new_branch.repository
-        new_repo.lock_read()
-        try:
+        with new_repo.lock_read():
             self.assertEqual(new_repo.get_parent_map([trunk_revid]),
                              {trunk_revid: (NULL_REVISION, )})
-        finally:
-            new_repo.unlock()
 
     def test_sprout_stacked(self):
         # We have a mainline

=== modified file 'breezy/tests/per_pack_repository.py'
--- breezy/tests/per_pack_repository.py	2019-05-29 03:22:34 +0000
+++ breezy/tests/per_pack_repository.py	2019-07-27 23:18:50 +0000
@@ -424,12 +424,10 @@
         self.make_repository('.', shared=True, format=format)
         r1 = repository.Repository.open('.')
         r2 = repository.Repository.open('.')
-        r1.lock_write()
-        try:
+        with r1.lock_write():
             # access enough data to load the names list
             list(r1.all_revision_ids())
-            r2.lock_write()
-            try:
+            with r2.lock_write():
                 # access enough data to load the names list
                 list(r2.all_revision_ids())
                 r1.start_write_group()
@@ -462,10 +460,6 @@
                 self.assertEqual(r1._pack_collection.names(),
                                  r2._pack_collection.names())
                 self.assertEqual(2, len(r1._pack_collection.names()))
-            finally:
-                r2.unlock()
-        finally:
-            r1.unlock()
 
     def test_concurrent_writer_second_preserves_dropping_a_pack(self):
         format = self.get_format()
@@ -526,32 +520,24 @@
     def test_concurrent_pack_triggers_reload(self):
         # create 2 packs, which we will then collapse
         tree = self.make_branch_and_tree('tree')
-        tree.lock_write()
-        try:
+        with tree.lock_write():
             rev1 = tree.commit('one')
             rev2 = tree.commit('two')
             r2 = repository.Repository.open('tree')
-            r2.lock_read()
-            try:
+            with r2.lock_read():
                 # Now r2 has read the pack-names file, but will need to reload
                 # it after r1 has repacked
                 tree.branch.repository.pack()
                 self.assertEqual({rev2: (rev1,)}, r2.get_parent_map([rev2]))
-            finally:
-                r2.unlock()
-        finally:
-            tree.unlock()
 
     def test_concurrent_pack_during_get_record_reloads(self):
         tree = self.make_branch_and_tree('tree')
-        tree.lock_write()
-        try:
+        with tree.lock_write():
             rev1 = tree.commit('one')
             rev2 = tree.commit('two')
             keys = [(rev1,), (rev2,)]
             r2 = repository.Repository.open('tree')
-            r2.lock_read()
-            try:
+            with r2.lock_read():
                 # At this point, we will start grabbing a record stream, and
                 # trigger a repack mid-way
                 packed = False
@@ -566,20 +552,14 @@
                 # The first record will be found in the original location, but
                 # after the pack, we have to reload to find the next record
                 self.assertEqual(sorted(keys), sorted(result.keys()))
-            finally:
-                r2.unlock()
-        finally:
-            tree.unlock()
 
     def test_concurrent_pack_during_autopack(self):
         tree = self.make_branch_and_tree('tree')
-        tree.lock_write()
-        try:
+        with tree.lock_write():
             for i in range(9):
                 tree.commit('rev %d' % (i,))
             r2 = repository.Repository.open('tree')
-            r2.lock_write()
-            try:
+            with r2.lock_write():
                 # Monkey patch so that pack occurs while the other repo is
                 # autopacking. This is slightly bad, but all current pack
                 # repository implementations have a _pack_collection, and we
@@ -603,10 +583,6 @@
                 # should be only 1 for 10 commits. So it goes ahead and
                 # finishes autopacking.
                 self.assertEqual([2], autopack_count)
-            finally:
-                r2.unlock()
-        finally:
-            tree.unlock()
 
     def test_lock_write_does_not_physically_lock(self):
         repo = self.make_repository('.', format=self.get_format())

=== modified file 'breezy/tests/per_repository/test_write_group.py'
--- breezy/tests/per_repository/test_write_group.py	2017-05-21 18:10:28 +0000
+++ breezy/tests/per_repository/test_write_group.py	2019-07-27 23:18:50 +0000
@@ -34,11 +34,8 @@
 
     def test_start_write_group_read_locked_needs_write_lock(self):
         repo = self.make_repository('.')
-        repo.lock_read()
-        try:
+        with repo.lock_read():
             self.assertRaises(errors.NotWriteLocked, repo.start_write_group)
-        finally:
-            repo.unlock()
 
     def test_start_write_group_write_locked_gets_None(self):
         repo = self.make_repository('.')

=== modified file 'breezy/tests/per_repository_vf/test_check.py'
--- breezy/tests/per_repository_vf/test_check.py	2018-11-11 04:08:32 +0000
+++ breezy/tests/per_repository_vf/test_check.py	2019-07-27 23:18:50 +0000
@@ -66,11 +66,8 @@
         if not repo._format.revision_graph_can_have_wrong_parents:
             raise TestNotApplicable(
                 '%r cannot have corrupt revision index.' % repo)
-        repo.lock_read()
-        try:
+        with repo.lock_read():
             repo._check_for_inconsistent_revision_parents()  # nothing happens
-        finally:
-            repo.unlock()
 
     def test_check_reports_bad_ancestor(self):
         repo = self.make_repo_with_extra_ghost_index()

=== modified file 'breezy/tests/per_repository_vf/test_reconcile.py'
--- breezy/tests/per_repository_vf/test_reconcile.py	2018-11-30 12:39:04 +0000
+++ breezy/tests/per_repository_vf/test_reconcile.py	2019-07-27 23:18:50 +0000
@@ -410,15 +410,12 @@
     def test_reconcile_wrong_order(self):
         # a wrong order in primary parents is optionally correctable
         repo = self.first_tree.branch.repository
-        repo.lock_read()
-        try:
+        with repo.lock_read():
             g = repo.get_graph()
             if g.get_parent_map([b'wrong-first-parent'])[b'wrong-first-parent'] \
                     == (b'1', b'2'):
                 raise TestSkipped(
                     'wrong-first-parent is not setup for testing')
-        finally:
-            repo.unlock()
         self.checkUnreconciled(repo.controldir, repo.reconcile())
         # nothing should have been altered yet : inventories without
         # revisions are not data loss incurring for current format

=== modified file 'breezy/tests/test_cleanup.py'
--- breezy/tests/test_cleanup.py	2018-11-11 04:08:32 +0000
+++ breezy/tests/test_cleanup.py	2019-07-27 23:18:50 +0000
@@ -17,280 +17,384 @@
 import re
 
 from ..cleanup import (
-    _do_with_cleanups,
-    _run_cleanup,
-    ObjectWithCleanups,
-    OperationWithCleanups,
+    ExitStack,
     )
+from ..sixish import PY3
 from .. import (
-    debug,
     tests,
     )
 
-
-class ErrorA(Exception):
-    """Sample exception type A."""
-
-
-class ErrorB(Exception):
-    """Sample exception type B."""
-
-
-class CleanupsTestCase(tests.TestCase):
-
-    def setUp(self):
-        super(CleanupsTestCase, self).setUp()
-        self.call_log = []
-
-    def no_op_cleanup(self):
-        self.call_log.append('no_op_cleanup')
-
-    def assertLogContains(self, regex):
-        self.assertContainsRe(self.get_log(), regex, re.DOTALL)
-
-    def failing_cleanup(self):
-        self.call_log.append('failing_cleanup')
-        raise Exception("failing_cleanup goes boom!")
-
-
-class TestRunCleanup(CleanupsTestCase):
-
-    def test_no_errors(self):
-        """The function passed to _run_cleanup is run."""
-        self.assertTrue(_run_cleanup(self.no_op_cleanup))
-        self.assertEqual(['no_op_cleanup'], self.call_log)
-
-    def test_cleanup_with_args_kwargs(self):
-        def func_taking_args_kwargs(*args, **kwargs):
-            self.call_log.append(('func', args, kwargs))
-        _run_cleanup(func_taking_args_kwargs, 'an arg', kwarg='foo')
-        self.assertEqual(
-            [('func', ('an arg',), {'kwarg': 'foo'})], self.call_log)
-
-    def test_cleanup_error(self):
-        """An error from the cleanup function is logged by _run_cleanup, but not
-        propagated.
-
-        This is there's no way for _run_cleanup to know if there's an existing
-        exception in this situation::
-            try:
-              some_func()
-            finally:
-              _run_cleanup(cleanup_func)
-        So, the best _run_cleanup can do is always log errors but never raise
-        them.
-        """
-        self.assertFalse(_run_cleanup(self.failing_cleanup))
-        self.assertLogContains('Cleanup failed:.*failing_cleanup goes boom')
-
-    def test_cleanup_error_debug_flag(self):
-        """The -Dcleanup debug flag causes cleanup errors to be reported to the
-        user.
-        """
-        debug.debug_flags.add('cleanup')
-        self.assertFalse(_run_cleanup(self.failing_cleanup))
-        self.assertContainsRe(
-            self.get_log(),
-            "brz: warning: Cleanup failed:.*failing_cleanup goes boom")
-
-    def test_prior_error_cleanup_succeeds(self):
-        """Calling _run_cleanup from a finally block will not interfere with an
-        exception from the try block.
-        """
-        def failing_operation():
-            try:
-                1 / 0
-            finally:
-                _run_cleanup(self.no_op_cleanup)
-        self.assertRaises(ZeroDivisionError, failing_operation)
-        self.assertEqual(['no_op_cleanup'], self.call_log)
-
-    def test_prior_error_cleanup_fails(self):
-        """Calling _run_cleanup from a finally block will not interfere with an
-        exception from the try block even when the cleanup itself raises an
-        exception.
-
-        The cleanup exception will be logged.
-        """
-        def failing_operation():
-            try:
-                1 / 0
-            finally:
-                _run_cleanup(self.failing_cleanup)
-        self.assertRaises(ZeroDivisionError, failing_operation)
-        self.assertLogContains('Cleanup failed:.*failing_cleanup goes boom')
-
-
-class TestDoWithCleanups(CleanupsTestCase):
-
-    def trivial_func(self):
-        self.call_log.append('trivial_func')
-        return 'trivial result'
-
-    def test_runs_func(self):
-        """_do_with_cleanups runs the function it is given, and returns the
-        result.
-        """
-        result = _do_with_cleanups([], self.trivial_func)
-        self.assertEqual('trivial result', result)
-
-    def test_runs_cleanups(self):
-        """Cleanup functions are run (in the given order)."""
-        cleanup_func_1 = (self.call_log.append, ('cleanup 1',), {})
-        cleanup_func_2 = (self.call_log.append, ('cleanup 2',), {})
-        _do_with_cleanups([cleanup_func_1, cleanup_func_2], self.trivial_func)
-        self.assertEqual(
-            ['trivial_func', 'cleanup 1', 'cleanup 2'], self.call_log)
-
-    def failing_func(self):
-        self.call_log.append('failing_func')
-        1 / 0
-
-    def test_func_error_propagates(self):
-        """Errors from the main function are propagated (after running
-        cleanups).
-        """
-        self.assertRaises(
-            ZeroDivisionError, _do_with_cleanups,
-            [(self.no_op_cleanup, (), {})], self.failing_func)
-        self.assertEqual(['failing_func', 'no_op_cleanup'], self.call_log)
-
-    def test_func_error_trumps_cleanup_error(self):
-        """Errors from the main function a propagated even if a cleanup raises
-        an error.
-
-        The cleanup error is be logged.
-        """
-        self.assertRaises(
-            ZeroDivisionError, _do_with_cleanups,
-            [(self.failing_cleanup, (), {})], self.failing_func)
-        self.assertLogContains('Cleanup failed:.*failing_cleanup goes boom')
-
-    def test_func_passes_and_error_from_cleanup(self):
-        """An error from a cleanup is propagated when the main function doesn't
-        raise an error.  Later cleanups are still executed.
-        """
-        exc = self.assertRaises(
-            Exception, _do_with_cleanups,
-            [(self.failing_cleanup, (), {}), (self.no_op_cleanup, (), {})],
-            self.trivial_func)
-        self.assertEqual('failing_cleanup goes boom!', exc.args[0])
-        self.assertEqual(
-            ['trivial_func', 'failing_cleanup', 'no_op_cleanup'],
-            self.call_log)
-
-    def test_multiple_cleanup_failures(self):
-        """When multiple cleanups fail (as tends to happen when something has
-        gone wrong), the first error is propagated, and subsequent errors are
-        logged.
-        """
-        cleanups = self.make_two_failing_cleanup_funcs()
-        self.assertRaises(ErrorA, _do_with_cleanups, cleanups,
-                          self.trivial_func)
-        self.assertLogContains('Cleanup failed:.*ErrorB')
-        # Error A may appear in the log (with Python 3 exception chaining), but
-        # Error B should be the last error recorded.
-        self.assertContainsRe(
-            self.get_log(),
-            'Traceback \\(most recent call last\\):\n(  .*\n)+'
-            '.*ErrorB: Error B\n$')
-
-    def make_two_failing_cleanup_funcs(self):
-        def raise_a():
-            raise ErrorA('Error A')
-
-        def raise_b():
-            raise ErrorB('Error B')
-        return [(raise_a, (), {}), (raise_b, (), {})]
-
-    def test_multiple_cleanup_failures_debug_flag(self):
-        debug.debug_flags.add('cleanup')
-        cleanups = self.make_two_failing_cleanup_funcs()
-        self.assertRaises(ErrorA, _do_with_cleanups, cleanups,
-                          self.trivial_func)
-        trace_value = self.get_log()
-        self.assertContainsRe(
-            trace_value, "brz: warning: Cleanup failed:.*Error B\n")
-        self.assertEqual(1, trace_value.count('brz: warning:'))
-
-    def test_func_and_cleanup_errors_debug_flag(self):
-        debug.debug_flags.add('cleanup')
-        cleanups = self.make_two_failing_cleanup_funcs()
-        self.assertRaises(ZeroDivisionError, _do_with_cleanups, cleanups,
-                          self.failing_func)
-        trace_value = self.get_log()
-        self.assertContainsRe(
-            trace_value, "brz: warning: Cleanup failed:.*Error A\n")
-        self.assertContainsRe(
-            trace_value, "brz: warning: Cleanup failed:.*Error B\n")
-        self.assertEqual(2, trace_value.count('brz: warning:'))
-
-    def test_func_may_mutate_cleanups(self):
-        """The main func may mutate the cleanups before it returns.
-
-        This allows a function to gradually add cleanups as it acquires
-        resources, rather than planning all the cleanups up-front.  The
-        OperationWithCleanups helper relies on this working.
-        """
-        cleanups_list = []
-
-        def func_that_adds_cleanups():
-            self.call_log.append('func_that_adds_cleanups')
-            cleanups_list.append((self.no_op_cleanup, (), {}))
-            return 'result'
-        result = _do_with_cleanups(cleanups_list, func_that_adds_cleanups)
-        self.assertEqual('result', result)
-        self.assertEqual(
-            ['func_that_adds_cleanups', 'no_op_cleanup'], self.call_log)
-
-    def test_cleanup_error_debug_flag(self):
-        """The -Dcleanup debug flag causes cleanup errors to be reported to the
-        user.
-        """
-        debug.debug_flags.add('cleanup')
-        self.assertRaises(ZeroDivisionError, _do_with_cleanups,
-                          [(self.failing_cleanup, (), {})], self.failing_func)
-        trace_value = self.get_log()
-        self.assertContainsRe(
-            trace_value,
-            "brz: warning: Cleanup failed:.*failing_cleanup goes boom")
-        self.assertEqual(1, trace_value.count('brz: warning:'))
-
-
-class TestOperationWithCleanups(CleanupsTestCase):
-
-    def test_cleanup_ordering(self):
-        """Cleanups are added in LIFO order.
-
-        So cleanups added before run is called are run last, and the last
-        cleanup added during the func is run first.
-        """
-        call_log = []
-
-        def func(op, foo):
-            call_log.append(('func called', foo))
-            op.add_cleanup(call_log.append, 'cleanup 2')
-            op.add_cleanup(call_log.append, 'cleanup 1')
-            return 'result'
-        owc = OperationWithCleanups(func)
-        owc.add_cleanup(call_log.append, 'cleanup 4')
-        owc.add_cleanup(call_log.append, 'cleanup 3')
-        result = owc.run('foo')
-        self.assertEqual('result', result)
-        self.assertEqual(
-            [('func called', 'foo'), 'cleanup 1', 'cleanup 2', 'cleanup 3',
-             'cleanup 4'], call_log)
-
-
-class SampleWithCleanups(ObjectWithCleanups):
-    """Minimal ObjectWithCleanups subclass."""
-
-
-class TestObjectWithCleanups(tests.TestCase):
-
-    def test_object_with_cleanups(self):
-        a = []
-        s = SampleWithCleanups()
-        s.add_cleanup(a.append, 42)
-        s.cleanup_now()
-        self.assertEqual(a, [42])
+from contextlib import contextmanager
+
+
+check_exception_chaining = PY3
+
+
+# Imported from contextlib2's test_contextlib2.py
+# Copyright: Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
+#   2009, 2010, 2011 Python Software Foundation
+#
+# PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
+# --------------------------------------------
+# .
+# 1. This LICENSE AGREEMENT is between the Python Software Foundation
+# ("PSF"), and the Individual or Organization ("Licensee") accessing and
+# otherwise using this software ("Python") in source or binary form and
+# its associated documentation.
+# .
+# 2. Subject to the terms and conditions of this License Agreement, PSF hereby
+# grants Licensee a nonexclusive, royalty-free, world-wide license to reproduce,
+# analyze, test, perform and/or display publicly, prepare derivative works,
+# distribute, and otherwise use Python alone or in any derivative version,
+# provided, however, that PSF's License Agreement and PSF's notice of copyright,
+# i.e., "Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
+# 2011 Python Software Foundation; All Rights Reserved" are retained in Python
+# alone or in any derivative version prepared by Licensee.
+# .
+# 3. In the event Licensee prepares a derivative work that is based on
+# or incorporates Python or any part thereof, and wants to make
+# the derivative work available to others as provided herein, then
+# Licensee hereby agrees to include in any such work a brief summary of
+# the changes made to Python.
+# .
+# 4. PSF is making Python available to Licensee on an "AS IS"
+# basis.  PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
+# IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND
+# DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
+# FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON WILL NOT
+# INFRINGE ANY THIRD PARTY RIGHTS.
+# .
+# 5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON
+# FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS
+# A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON,
+# OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
+# .
+# 6. This License Agreement will automatically terminate upon a material
+# breach of its terms and conditions.
+# .
+# 7. Nothing in this License Agreement shall be deemed to create any
+# relationship of agency, partnership, or joint venture between PSF and
+# Licensee.  This License Agreement does not grant permission to use PSF
+# trademarks or trade name in a trademark sense to endorse or promote
+# products or services of Licensee, or any third party.
+# .
+# 8. By copying, installing or otherwise using Python, Licensee
+# agrees to be bound by the terms and conditions of this License
+# Agreement.
+
+
+class TestExitStack(tests.TestCase):
+
+    def test_no_resources(self):
+        with ExitStack():
+            pass
+
+    def test_callback(self):
+        expected = [
+            ((), {}),
+            ((1,), {}),
+            ((1, 2), {}),
+            ((), dict(example=1)),
+            ((1,), dict(example=1)),
+            ((1, 2), dict(example=1)),
+        ]
+        result = []
+        def _exit(*args, **kwds):
+            """Test metadata propagation"""
+            result.append((args, kwds))
+        with ExitStack() as stack:
+            for args, kwds in reversed(expected):
+                if args and kwds:
+                    f = stack.callback(_exit, *args, **kwds)
+                elif args:
+                    f = stack.callback(_exit, *args)
+                elif kwds:
+                    f = stack.callback(_exit, **kwds)
+                else:
+                    f = stack.callback(_exit)
+                self.assertIs(f, _exit)
+        self.assertEqual(result, expected)
+
+    def test_push(self):
+        exc_raised = ZeroDivisionError
+        def _expect_exc(exc_type, exc, exc_tb):
+            self.assertIs(exc_type, exc_raised)
+        def _suppress_exc(*exc_details):
+            return True
+        def _expect_ok(exc_type, exc, exc_tb):
+            self.assertIsNone(exc_type)
+            self.assertIsNone(exc)
+            self.assertIsNone(exc_tb)
+        class ExitCM(object):
+            def __init__(self, check_exc):
+                self.check_exc = check_exc
+            def __enter__(self):
+                self.fail("Should not be called!")
+            def __exit__(self, *exc_details):
+                self.check_exc(*exc_details)
+        with ExitStack() as stack:
+            stack.push(_expect_ok)
+            cm = ExitCM(_expect_ok)
+            stack.push(cm)
+            stack.push(_suppress_exc)
+            cm = ExitCM(_expect_exc)
+            stack.push(cm)
+            stack.push(_expect_exc)
+            stack.push(_expect_exc)
+            1 / 0
+
+    def test_enter_context(self):
+        class TestCM(object):
+            def __enter__(self):
+                result.append(1)
+            def __exit__(self, *exc_details):
+                result.append(3)
+
+        result = []
+        cm = TestCM()
+        with ExitStack() as stack:
+            @stack.callback  # Registered first => cleaned up last
+            def _exit():
+                result.append(4)
+            self.assertIsNotNone(_exit)
+            stack.enter_context(cm)
+            result.append(2)
+        self.assertEqual(result, [1, 2, 3, 4])
+
+    def test_close(self):
+        result = []
+        with ExitStack() as stack:
+            @stack.callback
+            def _exit():
+                result.append(1)
+            self.assertIsNotNone(_exit)
+            stack.close()
+            result.append(2)
+        self.assertEqual(result, [1, 2])
+
+    def test_pop_all(self):
+        result = []
+        with ExitStack() as stack:
+            @stack.callback
+            def _exit():
+                result.append(3)
+            self.assertIsNotNone(_exit)
+            new_stack = stack.pop_all()
+            result.append(1)
+        result.append(2)
+        new_stack.close()
+        self.assertEqual(result, [1, 2, 3])
+
+    def test_exit_raise(self):
+        def _raise():
+            with ExitStack() as stack:
+                stack.push(lambda *exc: False)
+                1 / 0
+        self.assertRaises(ZeroDivisionError, _raise)
+
+    def test_exit_suppress(self):
+        with ExitStack() as stack:
+            stack.push(lambda *exc: True)
+            1 / 0
+
+    def test_exit_exception_chaining_reference(self):
+        # Sanity check to make sure that ExitStack chaining matches
+        # actual nested with statements
+        class RaiseExc:
+            def __init__(self, exc):
+                self.exc = exc
+            def __enter__(self):
+                return self
+            def __exit__(self, *exc_details):
+                raise self.exc
+
+        class RaiseExcWithContext:
+            def __init__(self, outer, inner):
+                self.outer = outer
+                self.inner = inner
+            def __enter__(self):
+                return self
+            def __exit__(self, *exc_details):
+                try:
+                    raise self.inner
+                except:
+                    raise self.outer
+
+        class SuppressExc:
+            def __enter__(self):
+                return self
+            def __exit__(self, *exc_details):
+                self.__class__.saved_details = exc_details
+                return True
+
+        try:
+            with RaiseExc(IndexError):
+                with RaiseExcWithContext(KeyError, AttributeError):
+                    with SuppressExc():
+                        with RaiseExc(ValueError):
+                            1 / 0
+        except IndexError as exc:
+            if check_exception_chaining:
+                self.assertIsInstance(exc.__context__, KeyError)
+                self.assertIsInstance(exc.__context__.__context__, AttributeError)
+                # Inner exceptions were suppressed
+                self.assertIsNone(exc.__context__.__context__.__context__)
+        else:
+            self.fail("Expected IndexError, but no exception was raised")
+        # Check the inner exceptions
+        inner_exc = SuppressExc.saved_details[1]
+        self.assertIsInstance(inner_exc, ValueError)
+        if check_exception_chaining:
+            self.assertIsInstance(inner_exc.__context__, ZeroDivisionError)
+
+    def test_exit_exception_chaining(self):
+        # Ensure exception chaining matches the reference behaviour
+        def raise_exc(exc):
+            raise exc
+
+        saved_details = [None]
+        def suppress_exc(*exc_details):
+            saved_details[0] = exc_details
+            return True
+
+        try:
+            with ExitStack() as stack:
+                stack.callback(raise_exc, IndexError)
+                stack.callback(raise_exc, KeyError)
+                stack.callback(raise_exc, AttributeError)
+                stack.push(suppress_exc)
+                stack.callback(raise_exc, ValueError)
+                1 / 0
+        except IndexError as exc:
+            if check_exception_chaining:
+                self.assertIsInstance(exc.__context__, KeyError)
+                self.assertIsInstance(exc.__context__.__context__, AttributeError)
+                # Inner exceptions were suppressed
+                self.assertIsNone(exc.__context__.__context__.__context__)
+        else:
+            self.fail("Expected IndexError, but no exception was raised")
+        # Check the inner exceptions
+        inner_exc = saved_details[0][1]
+        self.assertIsInstance(inner_exc, ValueError)
+        if check_exception_chaining:
+            self.assertIsInstance(inner_exc.__context__, ZeroDivisionError)
+
+    def test_exit_exception_non_suppressing(self):
+        # http://bugs.python.org/issue19092
+        def raise_exc(exc):
+            raise exc
+
+        def suppress_exc(*exc_details):
+            return True
+
+        try:
+            with ExitStack() as stack:
+                stack.callback(lambda: None)
+                stack.callback(raise_exc, IndexError)
+        except Exception as exc:
+            self.assertIsInstance(exc, IndexError)
+        else:
+            self.fail("Expected IndexError, but no exception was raised")
+
+        try:
+            with ExitStack() as stack:
+                stack.callback(raise_exc, KeyError)
+                stack.push(suppress_exc)
+                stack.callback(raise_exc, IndexError)
+        except Exception as exc:
+            self.assertIsInstance(exc, KeyError)
+        else:
+            self.fail("Expected KeyError, but no exception was raised")
+
+    def test_exit_exception_with_correct_context(self):
+        # http://bugs.python.org/issue20317
+        @contextmanager
+        def gets_the_context_right(exc):
+            try:
+                yield
+            finally:
+                raise exc
+
+        exc1 = Exception(1)
+        exc2 = Exception(2)
+        exc3 = Exception(3)
+        exc4 = Exception(4)
+
+        # The contextmanager already fixes the context, so prior to the
+        # fix, ExitStack would try to fix it *again* and get into an
+        # infinite self-referential loop
+        try:
+            with ExitStack() as stack:
+                stack.enter_context(gets_the_context_right(exc4))
+                stack.enter_context(gets_the_context_right(exc3))
+                stack.enter_context(gets_the_context_right(exc2))
+                raise exc1
+        except Exception as exc:
+            self.assertIs(exc, exc4)
+            if check_exception_chaining:
+                self.assertIs(exc.__context__, exc3)
+                self.assertIs(exc.__context__.__context__, exc2)
+                self.assertIs(exc.__context__.__context__.__context__, exc1)
+                self.assertIsNone(
+                    exc.__context__.__context__.__context__.__context__)
+
+    def test_exit_exception_with_existing_context(self):
+        # Addresses a lack of test coverage discovered after checking in a
+        # fix for issue 20317 that still contained debugging code.
+        def raise_nested(inner_exc, outer_exc):
+            try:
+                raise inner_exc
+            finally:
+                raise outer_exc
+        exc1 = Exception(1)
+        exc2 = Exception(2)
+        exc3 = Exception(3)
+        exc4 = Exception(4)
+        exc5 = Exception(5)
+        try:
+            with ExitStack() as stack:
+                stack.callback(raise_nested, exc4, exc5)
+                stack.callback(raise_nested, exc2, exc3)
+                raise exc1
+        except Exception as exc:
+            self.assertIs(exc, exc5)
+            if check_exception_chaining:
+                self.assertIs(exc.__context__, exc4)
+                self.assertIs(exc.__context__.__context__, exc3)
+                self.assertIs(exc.__context__.__context__.__context__, exc2)
+                self.assertIs(
+                    exc.__context__.__context__.__context__.__context__, exc1)
+                self.assertIsNone(
+                    exc.__context__.__context__.__context__.__context__.__context__)
+
+    def test_body_exception_suppress(self):
+        def suppress_exc(*exc_details):
+            return True
+        try:
+            with ExitStack() as stack:
+                stack.push(suppress_exc)
+                1 / 0
+        except IndexError as exc:
+            self.fail("Expected no exception, got IndexError")
+
+    def test_exit_exception_chaining_suppress(self):
+        with ExitStack() as stack:
+            stack.push(lambda *exc: True)
+            stack.push(lambda *exc: 1 / 0)
+            stack.push(lambda *exc: {}[1])
+
+    def test_excessive_nesting(self):
+        # The original implementation would die with RecursionError here
+        with ExitStack() as stack:
+            for i in range(10000):
+                stack.callback(int)
+
+    def test_instance_bypass(self):
+        class Example(object):
+            pass
+        cm = Example()
+        cm.__exit__ = object()
+        stack = ExitStack()
+        self.assertRaises(AttributeError, stack.enter_context, cm)
+        stack.push(cm)
+        # self.assertIs(stack._exit_callbacks[-1], cm)

=== modified file 'breezy/tests/test_diff.py'
--- breezy/tests/test_diff.py	2019-07-07 17:32:25 +0000
+++ breezy/tests/test_diff.py	2019-07-27 23:18:50 +0000
@@ -21,6 +21,7 @@
 import tempfile
 
 from .. import (
+    cleanup,
     diff,
     errors,
     osutils,
@@ -1021,8 +1022,10 @@
 
     def call_gtabtd(self, path_list, revision_specs, old_url, new_url):
         """Call get_trees_and_branches_to_diff_locked."""
+        exit_stack = cleanup.ExitStack()
+        self.addCleanup(exit_stack.close)
         return diff.get_trees_and_branches_to_diff_locked(
-            path_list, revision_specs, old_url, new_url, self.addCleanup)
+            path_list, revision_specs, old_url, new_url, exit_stack)
 
     def test_basic(self):
         tree = self.make_branch_and_tree('tree')

=== modified file 'breezy/tests/test_merge.py'
--- breezy/tests/test_merge.py	2019-06-29 13:16:26 +0000
+++ breezy/tests/test_merge.py	2019-07-27 23:18:50 +0000
@@ -3179,26 +3179,23 @@
         :param merge_as: the path in a tree to add the new directory as.
         :returns: the conflicts from 'do_merge'.
         """
-        operation = cleanup.OperationWithCleanups(self._merge_into)
-        return operation.run(location, merge_as)
-
-    def _merge_into(self, op, location, merge_as):
-        # Open and lock the various tree and branch objects
-        wt, subdir_relpath = WorkingTree.open_containing(merge_as)
-        op.add_cleanup(wt.lock_write().unlock)
-        branch_to_merge, subdir_to_merge = _mod_branch.Branch.open_containing(
-            location)
-        op.add_cleanup(branch_to_merge.lock_read().unlock)
-        other_tree = branch_to_merge.basis_tree()
-        op.add_cleanup(other_tree.lock_read().unlock)
-        # Perform the merge
-        merger = _mod_merge.MergeIntoMerger(
-            this_tree=wt, other_tree=other_tree, other_branch=branch_to_merge,
-            target_subdir=subdir_relpath, source_subpath=subdir_to_merge)
-        merger.set_base_revision(_mod_revision.NULL_REVISION, branch_to_merge)
-        conflicts = merger.do_merge()
-        merger.set_pending()
-        return conflicts
+        with cleanup.ExitStack() as stack:
+            # Open and lock the various tree and branch objects
+            wt, subdir_relpath = WorkingTree.open_containing(merge_as)
+            stack.enter_context(wt.lock_write())
+            branch_to_merge, subdir_to_merge = _mod_branch.Branch.open_containing(
+                location)
+            stack.enter_context(branch_to_merge.lock_read())
+            other_tree = branch_to_merge.basis_tree()
+            stack.enter_context(other_tree.lock_read())
+            # Perform the merge
+            merger = _mod_merge.MergeIntoMerger(
+                this_tree=wt, other_tree=other_tree, other_branch=branch_to_merge,
+                target_subdir=subdir_relpath, source_subpath=subdir_to_merge)
+            merger.set_base_revision(_mod_revision.NULL_REVISION, branch_to_merge)
+            conflicts = merger.do_merge()
+            merger.set_pending()
+            return conflicts
 
     def assertTreeEntriesEqual(self, expected_entries, tree):
         """Assert that 'tree' contains the expected inventory entries.

=== modified file 'breezy/transform.py'
--- breezy/transform.py	2019-06-29 13:16:26 +0000
+++ breezy/transform.py	2019-07-27 23:18:50 +0000
@@ -33,6 +33,7 @@
 from breezy import (
     annotate,
     bencode,
+    cleanup,
     controldir,
     commit,
     conflicts,
@@ -2598,15 +2599,13 @@
     :param delta_from_tree: If true, build_tree may use the input Tree to
         generate the inventory delta.
     """
-    with wt.lock_tree_write(), tree.lock_read():
+    with cleanup.ExitStack() as exit_stack:
+        exit_stack.enter_context(wt.lock_tree_write())
+        exit_stack.enter_context(tree.lock_read())
         if accelerator_tree is not None:
-            accelerator_tree.lock_read()
-        try:
-            return _build_tree(tree, wt, accelerator_tree, hardlink,
-                               delta_from_tree)
-        finally:
-            if accelerator_tree is not None:
-                accelerator_tree.unlock()
+            exit_stack.enter_context(accelerator_tree.lock_read())
+        return _build_tree(tree, wt, accelerator_tree, hardlink,
+                           delta_from_tree)
 
 
 def _build_tree(tree, wt, accelerator_tree, hardlink, delta_from_tree):

=== modified file 'breezy/workingtree.py'
--- breezy/workingtree.py	2019-06-29 13:16:26 +0000
+++ breezy/workingtree.py	2019-07-27 23:18:50 +0000
@@ -41,6 +41,7 @@
 import stat
 
 from breezy import (
+    cleanup,
     conflicts as _mod_conflicts,
     errors,
     filters as _mod_filters,
@@ -994,31 +995,28 @@
     def revert(self, filenames=None, old_tree=None, backups=True,
                pb=None, report_changes=False):
         from .conflicts import resolve
-        with self.lock_tree_write():
+        with cleanup.ExitStack() as exit_stack:
+            exit_stack.enter_context(self.lock_tree_write())
             if old_tree is None:
                 basis_tree = self.basis_tree()
-                basis_tree.lock_read()
+                exit_stack.enter_context(basis_tree.lock_read())
                 old_tree = basis_tree
             else:
                 basis_tree = None
-            try:
-                conflicts = transform.revert(self, old_tree, filenames, backups, pb,
-                                             report_changes)
-                if filenames is None and len(self.get_parent_ids()) > 1:
-                    parent_trees = []
-                    last_revision = self.last_revision()
-                    if last_revision != _mod_revision.NULL_REVISION:
-                        if basis_tree is None:
-                            basis_tree = self.basis_tree()
-                            basis_tree.lock_read()
-                        parent_trees.append((last_revision, basis_tree))
-                    self.set_parent_trees(parent_trees)
-                    resolve(self)
-                else:
-                    resolve(self, filenames, ignore_misses=True, recursive=True)
-            finally:
-                if basis_tree is not None:
-                    basis_tree.unlock()
+            conflicts = transform.revert(self, old_tree, filenames, backups, pb,
+                                         report_changes)
+            if filenames is None and len(self.get_parent_ids()) > 1:
+                parent_trees = []
+                last_revision = self.last_revision()
+                if last_revision != _mod_revision.NULL_REVISION:
+                    if basis_tree is None:
+                        basis_tree = self.basis_tree()
+                        exit_stack.enter_context(basis_tree.lock_read())
+                    parent_trees.append((last_revision, basis_tree))
+                self.set_parent_trees(parent_trees)
+                resolve(self)
+            else:
+                resolve(self, filenames, ignore_misses=True, recursive=True)
             return conflicts
 
     def store_uncommitted(self):