Merge lp:~jelmer/bzr/private-update-revisions into lp:~jelmer/bzr/foreign

[Jelmer Vernooij]

Make InterBranch.update_revisions() private.

[Jelmer Vernooij (jelmer)]

Attempt to merge into lp:~jelmer/bzr/foreign failed due to conflicts:

text conflict in doc/en/release-notes/bzr-2.4.txt

=== modified file 'bzrlib/_dirstate_helpers_pyx.pyx'
--- bzrlib/_dirstate_helpers_pyx.pyx	2010-08-27 18:02:22 +0000
+++ bzrlib/_dirstate_helpers_pyx.pyx	2011-05-03 10:31:11 +0000
@@ -866,6 +866,7 @@
     # _st mode of the compiled stat objects.
     cdef int minikind, saved_minikind
     cdef void * details
+    cdef int worth_saving
     minikind = minikind_from_mode(stat_value.st_mode)
     if 0 == minikind:
         return None
@@ -900,6 +901,7 @@
     # If we have gotten this far, that means that we need to actually
     # process this entry.
     link_or_sha1 = None
+    worth_saving = 1
     if minikind == c'f':
         executable = self._is_executable(stat_value.st_mode,
                                          saved_executable)
@@ -916,10 +918,15 @@
             entry[1][0] = ('f', link_or_sha1, stat_value.st_size,
                            executable, packed_stat)
         else:
-            entry[1][0] = ('f', '', stat_value.st_size,
-                           executable, DirState.NULLSTAT)
+            # This file is not worth caching the sha1. Either it is too new, or
+            # it is newly added. Regardless, the only things we are changing
+            # are derived from the stat, and so are not worth caching. So we do
+            # *not* set the IN_MEMORY_MODIFIED flag. (But we'll save the
+            # updated values if there is *other* data worth saving.)
+            entry[1][0] = ('f', '', stat_value.st_size, executable,
+                           DirState.NULLSTAT)
+            worth_saving = 0
     elif minikind == c'd':
-        link_or_sha1 = None
         entry[1][0] = ('d', '', 0, False, packed_stat)
         if saved_minikind != c'd':
             # This changed from something into a directory. Make sure we
@@ -929,6 +936,10 @@
                 self._get_block_entry_index(entry[0][0], entry[0][1], 0)
             self._ensure_block(block_index, entry_index,
                                pathjoin(entry[0][0], entry[0][1]))
+        else:
+            # Any changes are derived trivially from the stat object, not worth
+            # re-writing a dirstate for just this
+            worth_saving = 0
     elif minikind == c'l':
         link_or_sha1 = self._read_link(abspath, saved_link_or_sha1)
         if self._cutoff_time is None:
@@ -940,7 +951,8 @@
         else:
             entry[1][0] = ('l', '', stat_value.st_size,
                            False, DirState.NULLSTAT)
-    self._dirblock_state = DirState.IN_MEMORY_MODIFIED
+    if worth_saving:
+        self._dirblock_state = DirState.IN_MEMORY_MODIFIED
     return link_or_sha1
 
 

=== modified file 'bzrlib/branch.py'
--- bzrlib/branch.py	2011-04-21 00:20:51 +0000
+++ bzrlib/branch.py	2011-05-03 10:31:11 +0000
@@ -669,20 +669,15 @@
         raise errors.UnsupportedOperation(self.get_reference_info, self)
 
     @needs_write_lock
-    def fetch(self, from_branch, last_revision=None, fetch_spec=None):
+    def fetch(self, from_branch, last_revision=None):
         """Copy revisions from from_branch into this branch.
 
         :param from_branch: Where to copy from.
         :param last_revision: What revision to stop at (None for at the end
                               of the branch.
-        :param fetch_spec: If specified, a SearchResult or
-            PendingAncestryResult that describes which revisions to copy.  This
-            allows copying multiple heads at once.  Mutually exclusive with
-            last_revision.
         :return: None
         """
-        return InterBranch.get(from_branch, self).fetch(last_revision,
-            fetch_spec)
+        return InterBranch.get(from_branch, self).fetch(last_revision)
 
     def get_bound_location(self):
         """Return the URL of the branch we are bound to.
@@ -999,23 +994,6 @@
         else:
             return (0, _mod_revision.NULL_REVISION)
 
-    def update_revisions(self, other, stop_revision=None, overwrite=False,
-                         graph=None, fetch_tags=True):
-        """Pull in new perfect-fit revisions.
-
-        :param other: Another Branch to pull from
-        :param stop_revision: Updated until the given revision
-        :param overwrite: Always set the branch pointer, rather than checking
-            to see if it is a proper descendant.
-        :param graph: A Graph object that can be used to query history
-            information. This can be None.
-        :param fetch_tags: Flag that specifies if tags from other should be
-            fetched too.
-        :return: None
-        """
-        return InterBranch.get(other, self).update_revisions(stop_revision,
-            overwrite, graph, fetch_tags=fetch_tags)
-
     @deprecated_method(deprecated_in((2, 4, 0)))
     def import_last_revision_info(self, source_repo, revno, revid):
         """Set the last revision info, importing from another repo if necessary.
@@ -1045,14 +1023,7 @@
             (should only be different from the arguments when lossy=True)
         """
         if not self.repository.has_same_location(source.repository):
-            try:
-                tags_to_fetch = set(source.tags.get_reverse_tag_dict())
-            except errors.TagsNotSupported:
-                tags_to_fetch = set()
-            fetch_spec = _mod_graph.NotInOtherForRevs(self.repository,
-                source.repository, [revid],
-                if_present_ids=tags_to_fetch).execute()
-            self.repository.fetch(source.repository, fetch_spec=fetch_spec)
+            self.fetch(source, revid)
         self.set_last_revision_info(revno, revid)
         return (revno, revid)
 
@@ -2625,27 +2596,6 @@
                 pass
         return None
 
-    def _basic_push(self, target, overwrite, stop_revision):
-        """Basic implementation of push without bound branches or hooks.
-
-        Must be called with source read locked and target write locked.
-        """
-        result = BranchPushResult()
-        result.source_branch = self
-        result.target_branch = target
-        result.old_revno, result.old_revid = target.last_revision_info()
-        self.update_references(target)
-        if result.old_revid != stop_revision:
-            # We assume that during 'push' this repository is closer than
-            # the target.
-            graph = self.repository.get_graph(target.repository)
-            target.update_revisions(self, stop_revision,
-                overwrite=overwrite, graph=graph)
-        if self._push_should_merge_tags():
-            result.tag_conflicts = self.tags.merge_to(target.tags, overwrite)
-        result.new_revno, result.new_revid = target.last_revision_info()
-        return result
-
     def get_stacked_on_url(self):
         raise errors.UnstackableBranchFormat(self._format, self.user_url)
 
@@ -3301,22 +3251,6 @@
         raise NotImplementedError(self.pull)
 
     @needs_write_lock
-    def update_revisions(self, stop_revision=None, overwrite=False,
-                         graph=None, fetch_tags=True):
-        """Pull in new perfect-fit revisions.
-
-        :param stop_revision: Updated until the given revision
-        :param overwrite: Always set the branch pointer, rather than checking
-            to see if it is a proper descendant.
-        :param graph: A Graph object that can be used to query history
-            information. This can be None.
-        :param fetch_tags: Flag that specifies if tags from source should be
-            fetched too.
-        :return: None
-        """
-        raise NotImplementedError(self.update_revisions)
-
-    @needs_write_lock
     def push(self, overwrite=False, stop_revision=None,
              _override_hook_source_branch=None):
         """Mirror the source branch into the target branch.
@@ -3335,11 +3269,10 @@
         raise NotImplementedError(self.copy_content_into)
 
     @needs_write_lock
-    def fetch(self, stop_revision=None, fetch_spec=None):
+    def fetch(self, stop_revision=None):
         """Fetch revisions.
 
         :param stop_revision: Last revision to fetch
-        :param fetch_spec: Fetch spec.
         """
         raise NotImplementedError(self.fetch)
 
@@ -3383,26 +3316,26 @@
             self.source.tags.merge_to(self.target.tags)
 
     @needs_write_lock
-    def fetch(self, stop_revision=None, fetch_spec=None):
-        if fetch_spec is not None and stop_revision is not None:
-            raise AssertionError(
-                "fetch_spec and last_revision are mutually exclusive.")
+    def fetch(self, stop_revision=None):
         if self.target.base == self.source.base:
             return (0, [])
         self.source.lock_read()
         try:
-            if stop_revision is None and fetch_spec is None:
-                stop_revision = self.source.last_revision()
-                stop_revision = _mod_revision.ensure_null(stop_revision)
+            fetch_spec_factory = fetch.FetchSpecFactory()
+            fetch_spec_factory.source_branch = self.source
+            fetch_spec_factory.source_branch_stop_revision_id = stop_revision
+            fetch_spec_factory.source_repo = self.source.repository
+            fetch_spec_factory.target_repo = self.target.repository
+            fetch_spec_factory.target_repo_kind = fetch.TargetRepoKinds.PREEXISTING
+            fetch_spec = fetch_spec_factory.make_fetch_spec()
             return self.target.repository.fetch(self.source.repository,
-                revision_id=stop_revision, fetch_spec=fetch_spec)
+                fetch_spec=fetch_spec)
         finally:
             self.source.unlock()
 
     @needs_write_lock
-    def update_revisions(self, stop_revision=None, overwrite=False,
-        graph=None, fetch_tags=True):
-        """See InterBranch.update_revisions()."""
+    def _update_revisions(self, stop_revision=None, overwrite=False,
+            graph=None):
         other_revno, other_last_revision = self.source.last_revision_info()
         stop_revno = None # unknown
         if stop_revision is None:
@@ -3419,18 +3352,7 @@
         # case of having something to pull, and so that the check for
         # already merged can operate on the just fetched graph, which will
         # be cached in memory.
-        if fetch_tags:
-            fetch_spec_factory = fetch.FetchSpecFactory()
-            fetch_spec_factory.source_branch = self.source
-            fetch_spec_factory.source_branch_stop_revision_id = stop_revision
-            fetch_spec_factory.source_repo = self.source.repository
-            fetch_spec_factory.target_repo = self.target.repository
-            fetch_spec_factory.target_repo_kind = fetch.TargetRepoKinds.PREEXISTING
-            fetch_spec = fetch_spec_factory.make_fetch_spec()
-        else:
-            fetch_spec = _mod_graph.NotInOtherForRevs(self.target.repository,
-                self.source.repository, revision_ids=[stop_revision]).execute()
-        self.target.fetch(self.source, fetch_spec=fetch_spec)
+        self.fetch(stop_revision=stop_revision)
         # Check to see if one is an ancestor of the other
         if not overwrite:
             if graph is None:
@@ -3505,6 +3427,28 @@
         finally:
             self.source.unlock()
 
+    def _basic_push(self, overwrite, stop_revision):
+        """Basic implementation of push without bound branches or hooks.
+
+        Must be called with source read locked and target write locked.
+        """
+        result = BranchPushResult()
+        result.source_branch = self.source
+        result.target_branch = self.target
+        result.old_revno, result.old_revid = self.target.last_revision_info()
+        self.source.update_references(self.target)
+        if result.old_revid != stop_revision:
+            # We assume that during 'push' this repository is closer than
+            # the target.
+            graph = self.source.repository.get_graph(self.target.repository)
+            self._update_revisions(stop_revision, overwrite=overwrite,
+                    graph=graph)
+        if self.source._push_should_merge_tags():
+            result.tag_conflicts = self.source.tags.merge_to(self.target.tags,
+                overwrite)
+        result.new_revno, result.new_revid = self.target.last_revision_info()
+        return result
+
     def _push_with_bound_branches(self, overwrite, stop_revision,
             _override_hook_source_branch=None):
         """Push from source into target, and into target's master if any.
@@ -3525,12 +3469,12 @@
             master_branch.lock_write()
             try:
                 # push into the master from the source branch.
-                self.source._basic_push(master_branch, overwrite, stop_revision)
-                # and push into the target branch from the source. Note that we
-                # push from the source branch again, because it's considered the
-                # highest bandwidth repository.
-                result = self.source._basic_push(self.target, overwrite,
-                    stop_revision)
+                master_inter = InterBranch.get(self.source, master_branch)
+                master_inter._basic_push(overwrite, stop_revision)
+                # and push into the target branch from the source. Note that
+                # we push from the source branch again, because it's considered
+                # the highest bandwidth repository.
+                result = self._basic_push(overwrite, stop_revision)
                 result.master_branch = master_branch
                 result.local_branch = self.target
                 _run_hooks()
@@ -3539,8 +3483,7 @@
                 master_branch.unlock()
         else:
             # no master branch
-            result = self.source._basic_push(self.target, overwrite,
-                stop_revision)
+            result = self._basic_push(overwrite, stop_revision)
             # TODO: Why set master_branch and local_branch if there's no
             # binding?  Maybe cleaner to just leave them unset? -- mbp
             # 20070504
@@ -3589,8 +3532,8 @@
             # -- JRV20090506
             result.old_revno, result.old_revid = \
                 self.target.last_revision_info()
-            self.target.update_revisions(self.source, stop_revision,
-                overwrite=overwrite, graph=graph)
+            self._update_revisions(stop_revision, overwrite=overwrite,
+                graph=graph)
             # TODO: The old revid should be specified when merging tags, 
             # so a tags implementation that versions tags can only 
             # pull in the most recent changes. -- JRV20090506

=== modified file 'bzrlib/dirstate.py'
--- bzrlib/dirstate.py	2011-04-20 15:55:42 +0000
+++ bzrlib/dirstate.py	2011-05-03 10:31:11 +0000
@@ -3205,6 +3205,7 @@
     # If we have gotten this far, that means that we need to actually
     # process this entry.
     link_or_sha1 = None
+    worth_saving = True
     if minikind == 'f':
         executable = state._is_executable(stat_value.st_mode,
                                          saved_executable)
@@ -3226,6 +3227,7 @@
         else:
             entry[1][0] = ('f', '', stat_value.st_size,
                            executable, DirState.NULLSTAT)
+            worth_saving = False
     elif minikind == 'd':
         link_or_sha1 = None
         entry[1][0] = ('d', '', 0, False, packed_stat)
@@ -3237,6 +3239,8 @@
                 state._get_block_entry_index(entry[0][0], entry[0][1], 0)
             state._ensure_block(block_index, entry_index,
                                osutils.pathjoin(entry[0][0], entry[0][1]))
+        else:
+            worth_saving = False
     elif minikind == 'l':
         link_or_sha1 = state._read_link(abspath, saved_link_or_sha1)
         if state._cutoff_time is None:
@@ -3248,7 +3252,8 @@
         else:
             entry[1][0] = ('l', '', stat_value.st_size,
                            False, DirState.NULLSTAT)
-    state._dirblock_state = DirState.IN_MEMORY_MODIFIED
+    if worth_saving:
+        state._dirblock_state = DirState.IN_MEMORY_MODIFIED
     return link_or_sha1
 
 

=== modified file 'bzrlib/merge.py'
--- bzrlib/merge.py	2011-04-17 23:06:22 +0000
+++ bzrlib/merge.py	2011-05-03 10:31:11 +0000
@@ -563,14 +563,7 @@
 
     def _maybe_fetch(self, source, target, revision_id):
         if not source.repository.has_same_location(target.repository):
-            try:
-                tags_to_fetch = set(source.tags.get_reverse_tag_dict())
-            except errors.TagsNotSupported:
-                tags_to_fetch = None
-            fetch_spec = _mod_graph.NotInOtherForRevs(target.repository,
-                source.repository, [revision_id],
-                if_present_ids=tags_to_fetch).execute()
-            target.fetch(source, fetch_spec=fetch_spec)
+            target.fetch(source, revision_id)
 
     def find_base(self):
         revisions = [_mod_revision.ensure_null(self.this_basis),

=== modified file 'bzrlib/tests/per_branch/test_update.py'
--- bzrlib/tests/per_branch/test_update.py	2011-01-10 21:31:59 +0000
+++ bzrlib/tests/per_branch/test_update.py	2011-05-03 10:31:11 +0000
@@ -70,54 +70,6 @@
         self.assertEqual('foo', child_tree.branch.update())
         self.assertEqual(['bar'], child_tree.branch.revision_history())
 
-
-class TestUpdateRevisions(per_branch.TestCaseWithBranch):
-
-    def test_accepts_graph(self):
-        # An implementation may not use it, but it should allow a 'graph' to be
-        # supplied
-        tree1 = self.make_branch_and_tree('tree1')
-        rev1 = tree1.commit('one')
-        tree2 = tree1.bzrdir.sprout('tree2').open_workingtree()
-        rev2 = tree2.commit('two')
-
-        tree1.lock_write()
-        self.addCleanup(tree1.unlock)
-        tree2.lock_read()
-        self.addCleanup(tree2.unlock)
-        graph = tree2.branch.repository.get_graph(tree1.branch.repository)
-
-        tree1.branch.update_revisions(tree2.branch, graph=graph)
-        self.assertEqual((2, rev2), tree1.branch.last_revision_info())
-
-    def test_overwrite_ignores_diverged(self):
-        tree1 = self.make_branch_and_tree('tree1')
-        rev1 = tree1.commit('one')
-        tree2 = tree1.bzrdir.sprout('tree2').open_workingtree()
-        rev2 = tree1.commit('two')
-        rev2b = tree2.commit('alt two')
-
-        self.assertRaises(errors.DivergedBranches,
-                          tree1.branch.update_revisions,
-                          tree2.branch, overwrite=False)
-        # However, the revision should be copied into the repository
-        self.assertTrue(tree1.branch.repository.has_revision(rev2b))
-
-        tree1.branch.update_revisions(tree2.branch, overwrite=True)
-        self.assertEqual((2, rev2b), tree1.branch.last_revision_info())
-
-    def test_ignores_older_unless_overwrite(self):
-        tree1 = self.make_branch_and_tree('tree1')
-        rev1 = tree1.commit('one')
-        tree2 = tree1.bzrdir.sprout('tree2').open_workingtree()
-        rev2 = tree1.commit('two')
-
-        tree1.branch.update_revisions(tree2.branch)
-        self.assertEqual((2, rev2), tree1.branch.last_revision_info())
-
-        tree1.branch.update_revisions(tree2.branch, overwrite=True)
-        self.assertEqual((1, rev1), tree1.branch.last_revision_info())
-
     def test_update_in_checkout_of_readonly(self):
         tree1 = self.make_branch_and_tree('tree1')
         rev1 = tree1.commit('one')

=== modified file 'bzrlib/tests/per_interbranch/__init__.py'
--- bzrlib/tests/per_interbranch/__init__.py	2011-03-26 01:53:34 +0000
+++ bzrlib/tests/per_interbranch/__init__.py	2011-05-03 10:31:11 +0000
@@ -171,7 +171,6 @@
         'bzrlib.tests.per_interbranch.test_copy_content_into',
         'bzrlib.tests.per_interbranch.test_pull',
         'bzrlib.tests.per_interbranch.test_push',
-        'bzrlib.tests.per_interbranch.test_update_revisions',
         ])
     scenarios = make_scenarios(default_test_list())
     return multiply_tests(submod_tests, scenarios, standard_tests)

=== removed file 'bzrlib/tests/per_interbranch/test_update_revisions.py'
--- bzrlib/tests/per_interbranch/test_update_revisions.py	2010-06-17 09:23:19 +0000
+++ bzrlib/tests/per_interbranch/test_update_revisions.py	1970-01-01 00:00:00 +0000
@@ -1,70 +0,0 @@
-# Copyright (C) 2009, 2010 Canonical Ltd
-#
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 2 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
-
-from bzrlib import (
-    errors,
-    )
-from bzrlib.tests.per_interbranch import (
-    TestCaseWithInterBranch,
-    )
-
-
-class TestUpdateRevisions(TestCaseWithInterBranch):
-
-    def setUp(self):
-        super(TestUpdateRevisions, self).setUp()
-        self.tree1 = self.make_from_branch_and_tree('tree1')
-        rev1 = self.tree1.commit('one')
-        branch2 = self.make_to_branch('tree2')
-        branch2.repository.fetch(self.tree1.branch.repository)
-        self.tree1.branch.copy_content_into(branch2)
-        self.tree2 = branch2.bzrdir.create_workingtree()
-
-    def test_accepts_graph(self):
-        # An implementation may not use it, but it should allow a 'graph' to be
-        # supplied
-        rev2 = self.tree2.commit('two')
-
-        self.tree1.lock_write()
-        self.addCleanup(self.tree1.unlock)
-        self.tree2.lock_read()
-        self.addCleanup(self.tree2.unlock)
-        graph = self.tree2.branch.repository.get_graph(
-            self.tree1.branch.repository)
-
-        self.tree1.branch.update_revisions(self.tree2.branch, graph=graph)
-        self.assertEqual((2, rev2), self.tree1.branch.last_revision_info())
-
-    def test_overwrite_ignores_diverged(self):
-        rev2 = self.tree1.commit('two')
-        rev2b = self.tree2.commit('alt two')
-
-        self.assertRaises(errors.DivergedBranches,
-                          self.tree1.branch.update_revisions,
-                          self.tree2.branch, overwrite=False)
-        # However, the revision should be copied into the repository
-        self.assertTrue(self.tree1.branch.repository.has_revision(rev2b))
-
-        self.tree1.branch.update_revisions(self.tree2.branch, overwrite=True)
-        self.assertEqual((2, rev2b), self.tree1.branch.last_revision_info())
-
-    def test_ignores_older_unless_overwrite(self):
-        rev2 = self.tree1.commit('two')
-
-        self.tree1.branch.update_revisions(self.tree2.branch)
-        self.assertEqual((2, rev2), self.tree1.branch.last_revision_info())
-
-        self.tree1.branch.update_revisions(self.tree2.branch, overwrite=True)

=== modified file 'bzrlib/tests/test__dirstate_helpers.py'
--- bzrlib/tests/test__dirstate_helpers.py	2011-01-10 22:20:12 +0000
+++ bzrlib/tests/test__dirstate_helpers.py	2011-05-03 10:31:11 +0000
@@ -871,10 +871,12 @@
                                           stat_value=stat_value)
         self.assertEqual(None, link_or_sha1)
 
-        # The dirblock entry should not have cached the file's sha1 (too new)
+        # The dirblock entry should not have computed or cached the file's
+        # sha1, but it did update the files' st_size. However, this is not
+        # worth writing a dirstate file for, so we leave the state UNMODIFIED
         self.assertEqual(('f', '', 14, False, dirstate.DirState.NULLSTAT),
                          entry[1][0])
-        self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
+        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
                          state._dirblock_state)
         mode = stat_value.st_mode
         self.assertEqual([('is_exec', mode, False)], state._log)
@@ -883,9 +885,8 @@
         self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
                          state._dirblock_state)
 
-        # If we do it again right away, we don't know if the file has changed
-        # so we will re-read the file. Roll the clock back so the file is
-        # guaranteed to look too new.
+        # Roll the clock back so the file is guaranteed to look too new. We
+        # should still not compute the sha1.
         state.adjust_time(-10)
         del state._log[:]
 
@@ -893,7 +894,7 @@
                                           stat_value=stat_value)
         self.assertEqual([('is_exec', mode, False)], state._log)
         self.assertEqual(None, link_or_sha1)
-        self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
+        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
                          state._dirblock_state)
         self.assertEqual(('f', '', 14, False, dirstate.DirState.NULLSTAT),
                          entry[1][0])
@@ -909,6 +910,8 @@
         self.assertEqual([('is_exec', mode, False)], state._log)
         self.assertEqual(('f', '', 14, False, dirstate.DirState.NULLSTAT),
                          entry[1][0])
+        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
+                         state._dirblock_state)
 
         # If the file is no longer new, and the clock has been moved forward
         # sufficiently, it will cache the sha.
@@ -1005,12 +1008,25 @@
         self.build_tree(['a/'])
         state.adjust_time(+20)
         self.assertIs(None, self.do_update_entry(state, entry, 'a'))
+        # a/ used to be a file, but is now a directory, worth saving
         self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
                          state._dirblock_state)
         state.save()
         self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
                          state._dirblock_state)
-        self.assertIs(None, self.do_update_entry(state, entry, 'a'))
+        # No changes to a/ means not worth saving.
+        self.assertIs(None, self.do_update_entry(state, entry, 'a'))
+        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
+                         state._dirblock_state)
+        # Change the last-modified time for the directory
+        t = time.time() - 100.0
+        os.utime('a', (t, t))
+        saved_packed_stat = entry[1][0][-1]
+        self.assertIs(None, self.do_update_entry(state, entry, 'a'))
+        # We *do* go ahead and update the information in the dirblocks, but we
+        # don't bother setting IN_MEMORY_MODIFIED because it is trivial to
+        # recompute.
+        self.assertNotEqual(saved_packed_stat, entry[1][0][-1])
         self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
                          state._dirblock_state)
 

=== modified file 'bzrlib/tests/test_dirstate.py'
--- bzrlib/tests/test_dirstate.py	2011-01-25 22:54:08 +0000
+++ bzrlib/tests/test_dirstate.py	2011-05-03 10:31:11 +0000
@@ -527,6 +527,19 @@
 
 class TestDirStateOnFile(TestCaseWithDirState):
 
+    def create_updated_dirstate(self):
+        self.build_tree(['a-file'])
+        tree = self.make_branch_and_tree('.')
+        tree.add(['a-file'], ['a-id'])
+        tree.commit('add a-file')
+        # Save and unlock the state, re-open it in readonly mode
+        state = dirstate.DirState.from_tree(tree, 'dirstate')
+        state.save()
+        state.unlock()
+        state = dirstate.DirState.on_file('dirstate')
+        state.lock_read()
+        return state
+
     def test_construct_with_path(self):
         tree = self.make_branch_and_tree('tree')
         state = dirstate.DirState.from_tree(tree, 'dirstate.from_tree')
@@ -561,36 +574,24 @@
             state.unlock()
 
     def test_can_save_in_read_lock(self):
-        self.build_tree(['a-file'])
-        state = dirstate.DirState.initialize('dirstate')
-        try:
-            # No stat and no sha1 sum.
-            state.add('a-file', 'a-file-id', 'file', None, '')
-            state.save()
-        finally:
-            state.unlock()
-
-        # Now open in readonly mode
-        state = dirstate.DirState.on_file('dirstate')
-        state.lock_read()
+        state = self.create_updated_dirstate()
         try:
             entry = state._get_entry(0, path_utf8='a-file')
             # The current size should be 0 (default)
             self.assertEqual(0, entry[1][0][2])
             # We should have a real entry.
             self.assertNotEqual((None, None), entry)
-            # Make sure everything is old enough
+            # Set the cutoff-time into the future, so things look cacheable
             state._sha_cutoff_time()
-            state._cutoff_time += 10
-            # Change the file length
-            self.build_tree_contents([('a-file', 'shorter')])
-            sha1sum = dirstate.update_entry(state, entry, 'a-file',
-                os.lstat('a-file'))
-            # new file, no cached sha:
-            self.assertEqual(None, sha1sum)
+            state._cutoff_time += 10.0
+            st = os.lstat('a-file')
+            sha1sum = dirstate.update_entry(state, entry, 'a-file', st)
+            # We updated the current sha1sum because the file is cacheable
+            self.assertEqual('ecc5374e9ed82ad3ea3b4d452ea995a5fd3e70e3',
+                             sha1sum)
 
             # The dirblock has been updated
-            self.assertEqual(7, entry[1][0][2])
+            self.assertEqual(st.st_size, entry[1][0][2])
             self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
                              state._dirblock_state)
 
@@ -606,29 +607,24 @@
         state.lock_read()
         try:
             entry = state._get_entry(0, path_utf8='a-file')
-            self.assertEqual(7, entry[1][0][2])
+            self.assertEqual(st.st_size, entry[1][0][2])
         finally:
             state.unlock()
 
     def test_save_fails_quietly_if_locked(self):
         """If dirstate is locked, save will fail without complaining."""
-        self.build_tree(['a-file'])
-        state = dirstate.DirState.initialize('dirstate')
-        try:
-            # No stat and no sha1 sum.
-            state.add('a-file', 'a-file-id', 'file', None, '')
-            state.save()
-        finally:
-            state.unlock()
-
-        state = dirstate.DirState.on_file('dirstate')
-        state.lock_read()
+        state = self.create_updated_dirstate()
         try:
             entry = state._get_entry(0, path_utf8='a-file')
-            sha1sum = dirstate.update_entry(state, entry, 'a-file',
-                os.lstat('a-file'))
-            # No sha - too new
-            self.assertEqual(None, sha1sum)
+            # No cached sha1 yet.
+            self.assertEqual('', entry[1][0][1])
+            # Set the cutoff-time into the future, so things look cacheable
+            state._sha_cutoff_time()
+            state._cutoff_time += 10.0
+            st = os.lstat('a-file')
+            sha1sum = dirstate.update_entry(state, entry, 'a-file', st)
+            self.assertEqual('ecc5374e9ed82ad3ea3b4d452ea995a5fd3e70e3',
+                             sha1sum)
             self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
                              state._dirblock_state)
 

=== modified file 'bzrlib/tests/test_revisionspec.py'
--- bzrlib/tests/test_revisionspec.py	2011-04-14 07:53:38 +0000
+++ bzrlib/tests/test_revisionspec.py	2011-05-03 10:31:11 +0000
@@ -397,8 +397,7 @@
         """We can get any revision id in the repository"""
         # XXX: This may change in the future, but for now, it is true
         self.tree2.commit('alt third', rev_id='alt_r3')
-        self.tree.branch.repository.fetch(self.tree2.branch.repository,
-                                          revision_id='alt_r3')
+        self.tree.branch.fetch(self.tree2.branch, 'alt_r3')
         self.assertInHistoryIs(None, 'alt_r3', 'revid:alt_r3')
 
     def test_unicode(self):
@@ -475,8 +474,7 @@
     def test_alt_no_parents(self):
         new_tree = self.make_branch_and_tree('new_tree')
         new_tree.commit('first', rev_id='new_r1')
-        self.tree.branch.repository.fetch(new_tree.branch.repository,
-                                          revision_id='new_r1')
+        self.tree.branch.fetch(new_tree.branch, 'new_r1')
         self.assertInHistoryIs(0, 'null:', 'before:revid:new_r1')
 
     def test_as_revision_id(self):

=== modified file 'bzrlib/workingtree_4.py'
--- bzrlib/workingtree_4.py	2011-04-17 23:06:22 +0000
+++ bzrlib/workingtree_4.py	2011-05-03 10:31:11 +0000
@@ -2016,7 +2016,7 @@
     def make_source_parent_tree(source, target):
         """Change the source tree into a parent of the target."""
         revid = source.commit('record tree')
-        target.branch.repository.fetch(source.branch.repository, revid)
+        target.branch.fetch(source.branch, revid)
         target.set_parent_ids([revid])
         return target.basis_tree(), target
 

=== modified file 'doc/en/release-notes/bzr-2.4.txt'
--- doc/en/release-notes/bzr-2.4.txt	2011-04-21 00:20:51 +0000
+++ doc/en/release-notes/bzr-2.4.txt	2011-05-03 10:31:11 +0000
@@ -111,6 +111,10 @@
 .. Changes that may require updates in plugins or other code that uses
    bzrlib.
 
+* ``Branch.update_revisions`` has been made private and should no
+  longer be used by external users. Use ``Branch.pull`` or ``Branch.push``
+  instead. (Jelmer Vernooij, #771765)
+
 * Commands now have an `invoked_as` attribute, showing the name under
   which they were called before alias expansion.
   (Martin Pool)
@@ -304,6 +308,12 @@
 * ``bzr serve`` no longer crashes when a server_started hook is installed and
   IPv6 support is available on the system. (Jelmer Vernooij, #293697)
 
+* ``bzr status`` will not rewrite the dirstate file if it only has
+  'trivial' changes. (Currently limited to dir updates and newly-added
+  files changing state.) This saves a bit of time for regular operations.
+  eg. ``bzr status`` in a 100k tree takes 1.4s to compute the status, but 1s
+  to re-save the dirstate file. (John Arbash Meinel, #765881)
+
 * ``bzr tags`` will no longer choke on branches with ghost revisions in
   their mainline and tags on revisions not in the branch ancestry. 
   (Jelmer Vernooij, #397556)
@@ -360,7 +370,7 @@
   (Jelmer Vernooij)
 
 * ``Branch.fetch`` implementations must now accept an optional
-  ``fetch_spec`` keyword argument. (Andrew Bennetts)
+  ``fetch_tags`` keyword argument. (Andrew Bennetts)
 
 * ``Branch.import_last_revision_info`` is deprecated.  Use the
   ``import_last_revision_info_and_tags`` method instead.