localrepo: factor out parentworking logic for comparing files

We will temporarily call a private method of the context class while we are in
the process of removing the need of having localrepo.status.

mercurial/context.py

@@ -1197,6 +1197,39 b' class workingctx(committablectx):'
             sane.append(f)
         return sane
 
+    def _checklookup(self, files):
+        # check for any possibly clean files
+        if not files:
+            return [], []
+
+        modified = []
+        fixup = []
+        pctx = self._parents[0]
+        # do a full compare of any files that might have changed
+        for f in sorted(files):
+            if (f not in pctx or self.flags(f) != pctx.flags(f)
+                or pctx[f].cmp(self[f])):
+                modified.append(f)
+            else:
+                fixup.append(f)
+
+        # update dirstate for files that are actually clean
+        if fixup:
+            try:
+                # updating the dirstate is optional
+                # so we don't wait on the lock
+                normal = self._repo.dirstate.normal
+                wlock = self._repo.wlock(False)
+                try:
+                    for f in fixup:
+                        normal(f)
+                finally:
+                    wlock.release()
+            except error.LockError:
+                pass
+        return modified, fixup
+
+
 class committablefilectx(basefilectx):
     """A committablefilectx provides common functionality for a file context
     that wants the ability to commit, e.g. workingfilectx or memfilectx."""

mercurial/localrepo.py

@@ -1550,32 +1550,12 b' class localrepository(object):'
 
             # check for any possibly clean files
             if parentworking and cmp:
-                fixup = []
-                # do a full compare of any files that might have changed
-                for f in sorted(cmp):
-                    if (f not in ctx1 or ctx2.flags(f) != ctx1.flags(f)
-                        or ctx1[f].cmp(ctx2[f])):
-                        modified.append(f)
-                    else:
-                        fixup.append(f)
+                modified2, fixup = ctx2._checklookup(cmp)
+                modified += modified2
 
                 # update dirstate for files that are actually clean
-                if fixup:
-                    if listclean:
-                        clean += fixup
-
-                    try:
-                        # updating the dirstate is optional
-                        # so we don't wait on the lock
-                        normal = self.dirstate.normal
-                        wlock = self.wlock(False)
-                        try:
-                            for f in fixup:
-                                normal(f)
-                        finally:
-                            wlock.release()
-                    except error.LockError:
-                        pass
+                if fixup and listclean:
+                    clean += fixup
 
         if not parentworking:
             mf1 = mfmatches(ctx1)