Patchwork D4130: match: add visitchildrenset complement to visitdir

login
register
mail settings
Submitter phabricator
Date Aug. 6, 2018, 9:18 p.m.
Message ID <ea546d1d070e335624b42304d1147980@localhost.localdomain>
Download mbox | patch
Permalink /patch/33364/
State Not Applicable
Headers show

Comments

phabricator - Aug. 6, 2018, 9:18 p.m.
spectral updated this revision to Diff 10017.

REPOSITORY
  rHG Mercurial

CHANGES SINCE LAST UPDATE
  https://phab.mercurial-scm.org/D4130?vs=9999&id=10017

REVISION DETAIL
  https://phab.mercurial-scm.org/D4130

AFFECTED FILES
  mercurial/match.py
  tests/test-match.py

CHANGE DETAILS




To: spectral, #hg-reviewers
Cc: mercurial-devel
Yuya Nishihara - Aug. 8, 2018, 3:06 p.m.
> +    def testVisitchildrensetRootfilesin(self):
> +        m = matchmod.match('x', '', patterns=['rootfilesin:dir/subdir'])
> +        assert isinstance(m, matchmod.patternmatcher)
> +        self.assertEqual(m.visitchildrenset('.'), 'this')
> +        self.assertEqual(m.visitchildrenset('dir/subdir/x'), set())
> +        self.assertEqual(m.visitchildrenset('folder'), set())

> +        self.assertEqual(m.visitchildrenset('dir'), set())
> +        self.assertEqual(m.visitchildrenset('dir/subdir'), set())

I assumed these two have the same bug as the one mentioned in testVisitdirRootfilesin()

> @@ -748,6 +903,14 @@
>              return self._matcher.visitdir(dir[len(self._pathprefix):])
>          return dir in self._pathdirs
>  
> +    def visitchildrenset(self, dir):
> +        if dir == self._path:
> +            return self._matcher.visitchildrenset('.')
> +        if dir.startswith(self._pathprefix):
> +            return self._matcher.visitchildrenset(dir[len(self._pathprefix):])
> +        if dir in self._pathdirs:
> +            return 'this'

Maybe missing `return set()`?
phabricator - Aug. 8, 2018, 3:16 p.m.
yuja added a comment.


  > +    def testVisitchildrensetRootfilesin(self):
  >  +        m = matchmod.match('x', '', patterns=['rootfilesin:dir/subdir'])
  >  +        assert isinstance(m, matchmod.patternmatcher)
  >  +        self.assertEqual(m.visitchildrenset('.'), 'this')
  >  +        self.assertEqual(m.visitchildrenset('dir/subdir/x'), set())
  >  +        self.assertEqual(m.visitchildrenset('folder'), set())
  
  
  
  > +        self.assertEqual(m.visitchildrenset('dir'), set())
  >  +        self.assertEqual(m.visitchildrenset('dir/subdir'), set())
  
  I assumed these two have the same bug as the one mentioned in testVisitdirRootfilesin()
  
  > @@ -748,6 +903,14 @@
  > 
  >       return self._matcher.visitdir(dir[len(self._pathprefix):])
  >   return dir in self._pathdirs
  >     
  > 
  > +    def visitchildrenset(self, dir):
  >  +        if dir == self._path:
  >  +            return self._matcher.visitchildrenset('.')
  >  +        if dir.startswith(self._pathprefix):
  >  +            return self._matcher.visitchildrenset(dir[len(self._pathprefix):])
  >  +        if dir in self._pathdirs:
  >  +            return 'this'
  
  Maybe missing `return set()`?

REPOSITORY
  rHG Mercurial

REVISION DETAIL
  https://phab.mercurial-scm.org/D4130

To: spectral, #hg-reviewers
Cc: yuja, mercurial-devel

Patch

diff --git a/tests/test-match.py b/tests/test-match.py
--- a/tests/test-match.py
+++ b/tests/test-match.py
@@ -16,20 +16,35 @@ 
         self.assertTrue(m.visitdir('.'))
         self.assertTrue(m.visitdir('dir'))
 
+    def testVisitchildrenset(self):
+        m = matchmod.basematcher('', '')
+        self.assertEqual(m.visitchildrenset('.'), 'this')
+        self.assertEqual(m.visitchildrenset('dir'), 'this')
+
 class AlwaysMatcherTests(unittest.TestCase):
 
     def testVisitdir(self):
         m = matchmod.alwaysmatcher('', '')
         self.assertEqual(m.visitdir('.'), 'all')
         self.assertEqual(m.visitdir('dir'), 'all')
 
+    def testVisitchildrenset(self):
+        m = matchmod.alwaysmatcher('', '')
+        self.assertEqual(m.visitchildrenset('.'), 'all')
+        self.assertEqual(m.visitchildrenset('dir'), 'all')
+
 class NeverMatcherTests(unittest.TestCase):
 
     def testVisitdir(self):
         m = matchmod.nevermatcher('', '')
         self.assertFalse(m.visitdir('.'))
         self.assertFalse(m.visitdir('dir'))
 
+    def testVisitchildrenset(self):
+        m = matchmod.nevermatcher('', '')
+        self.assertEqual(m.visitchildrenset('.'), set())
+        self.assertEqual(m.visitchildrenset('dir'), set())
+
 class PredicateMatcherTests(unittest.TestCase):
     # predicatematcher does not currently define either of these methods, so
     # this is equivalent to BaseMatcherTests.
@@ -39,6 +54,11 @@ 
         self.assertTrue(m.visitdir('.'))
         self.assertTrue(m.visitdir('dir'))
 
+    def testVisitchildrenset(self):
+        m = matchmod.predicatematcher('', '', lambda *a: False)
+        self.assertEqual(m.visitchildrenset('.'), 'this')
+        self.assertEqual(m.visitchildrenset('dir'), 'this')
+
 class PatternMatcherTests(unittest.TestCase):
 
     def testVisitdirPrefix(self):
@@ -51,6 +71,16 @@ 
         self.assertTrue(m.visitdir('dir/subdir/x'))
         self.assertFalse(m.visitdir('folder'))
 
+    def testVisitchildrensetPrefix(self):
+        m = matchmod.match('x', '', patterns=['path:dir/subdir'])
+        assert isinstance(m, matchmod.patternmatcher)
+        self.assertEqual(m.visitchildrenset('.'), 'this')
+        self.assertEqual(m.visitchildrenset('dir'), 'this')
+        self.assertEqual(m.visitchildrenset('dir/subdir'), 'all')
+        # OPT: This should probably be 'all' if its parent is?
+        self.assertEqual(m.visitchildrenset('dir/subdir/x'), 'this')
+        self.assertEqual(m.visitchildrenset('folder'), set())
+
     def testVisitdirRootfilesin(self):
         m = matchmod.match('x', '', patterns=['rootfilesin:dir/subdir'])
         assert isinstance(m, matchmod.patternmatcher)
@@ -61,6 +91,15 @@ 
         self.assertFalse(m.visitdir('dir'))
         self.assertFalse(m.visitdir('dir/subdir'))
 
+    def testVisitchildrensetRootfilesin(self):
+        m = matchmod.match('x', '', patterns=['rootfilesin:dir/subdir'])
+        assert isinstance(m, matchmod.patternmatcher)
+        self.assertEqual(m.visitchildrenset('.'), 'this')
+        self.assertEqual(m.visitchildrenset('dir/subdir/x'), set())
+        self.assertEqual(m.visitchildrenset('folder'), set())
+        self.assertEqual(m.visitchildrenset('dir'), set())
+        self.assertEqual(m.visitchildrenset('dir/subdir'), set())
+
     def testVisitdirGlob(self):
         m = matchmod.match('x', '', patterns=['glob:dir/z*'])
         assert isinstance(m, matchmod.patternmatcher)
@@ -71,6 +110,16 @@ 
         self.assertTrue(m.visitdir('dir/subdir'))
         self.assertTrue(m.visitdir('dir/subdir/x'))
 
+    def testVisitchildrensetGlob(self):
+        m = matchmod.match('x', '', patterns=['glob:dir/z*'])
+        assert isinstance(m, matchmod.patternmatcher)
+        self.assertEqual(m.visitchildrenset('.'), 'this')
+        self.assertEqual(m.visitchildrenset('folder'), set())
+        self.assertEqual(m.visitchildrenset('dir'), 'this')
+        # OPT: these should probably be set().
+        self.assertEqual(m.visitchildrenset('dir/subdir'), 'this')
+        self.assertEqual(m.visitchildrenset('dir/subdir/x'), 'this')
+
 class IncludeMatcherTests(unittest.TestCase):
 
     def testVisitdirPrefix(self):
@@ -83,6 +132,16 @@ 
         self.assertTrue(m.visitdir('dir/subdir/x'))
         self.assertFalse(m.visitdir('folder'))
 
+    def testVisitchildrensetPrefix(self):
+        m = matchmod.match('x', '', include=['path:dir/subdir'])
+        assert isinstance(m, matchmod.includematcher)
+        self.assertEqual(m.visitchildrenset('.'), {'dir'})
+        self.assertEqual(m.visitchildrenset('dir'), {'subdir'})
+        self.assertEqual(m.visitchildrenset('dir/subdir'), 'all')
+        # OPT: This should probably be 'all' if its parent is?
+        self.assertEqual(m.visitchildrenset('dir/subdir/x'), 'this')
+        self.assertEqual(m.visitchildrenset('folder'), set())
+
     def testVisitdirRootfilesin(self):
         m = matchmod.match('x', '', include=['rootfilesin:dir/subdir'])
         assert isinstance(m, matchmod.includematcher)
@@ -92,6 +151,15 @@ 
         self.assertFalse(m.visitdir('dir/subdir/x'))
         self.assertFalse(m.visitdir('folder'))
 
+    def testVisitchildrensetRootfilesin(self):
+        m = matchmod.match('x', '', include=['rootfilesin:dir/subdir'])
+        assert isinstance(m, matchmod.includematcher)
+        self.assertEqual(m.visitchildrenset('.'), {'dir'})
+        self.assertEqual(m.visitchildrenset('dir'), {'subdir'})
+        self.assertEqual(m.visitchildrenset('dir/subdir'), 'this')
+        self.assertEqual(m.visitchildrenset('dir/subdir/x'), set())
+        self.assertEqual(m.visitchildrenset('folder'), set())
+
     def testVisitdirGlob(self):
         m = matchmod.match('x', '', include=['glob:dir/z*'])
         assert isinstance(m, matchmod.includematcher)
@@ -102,6 +170,16 @@ 
         self.assertTrue(m.visitdir('dir/subdir'))
         self.assertTrue(m.visitdir('dir/subdir/x'))
 
+    def testVisitchildrensetGlob(self):
+        m = matchmod.match('x', '', include=['glob:dir/z*'])
+        assert isinstance(m, matchmod.includematcher)
+        self.assertEqual(m.visitchildrenset('.'), {'dir'})
+        self.assertEqual(m.visitchildrenset('folder'), set())
+        self.assertEqual(m.visitchildrenset('dir'), 'this')
+        # OPT: these should probably be set().
+        self.assertEqual(m.visitchildrenset('dir/subdir'), 'this')
+        self.assertEqual(m.visitchildrenset('dir/subdir/x'), 'this')
+
 class ExactMatcherTests(unittest.TestCase):
 
     def testVisitdir(self):
@@ -115,6 +193,16 @@ 
         self.assertFalse(m.visitdir('dir/subdir/x'))
         self.assertFalse(m.visitdir('folder'))
 
+    def testVisitchildrenset(self):
+        m = matchmod.match('x', '', patterns=['dir/subdir/foo.txt'], exact=True)
+        assert isinstance(m, matchmod.exactmatcher)
+        self.assertEqual(m.visitchildrenset('.'), {'dir'})
+        self.assertEqual(m.visitchildrenset('dir'), {'subdir'})
+        self.assertEqual(m.visitchildrenset('dir/subdir'), 'this')
+        self.assertEqual(m.visitchildrenset('dir/subdir/x'), set())
+        self.assertEqual(m.visitchildrenset('dir/subdir/foo.txt'), set())
+        self.assertEqual(m.visitchildrenset('folder'), set())
+
 class DifferenceMatcherTests(unittest.TestCase):
 
     def testVisitdirM2always(self):
@@ -130,6 +218,19 @@ 
         self.assertFalse(dm.visitdir('dir/subdir/x'))
         self.assertFalse(dm.visitdir('folder'))
 
+    def testVisitchildrensetM2always(self):
+        m1 = matchmod.alwaysmatcher('', '')
+        m2 = matchmod.alwaysmatcher('', '')
+        dm = matchmod.differencematcher(m1, m2)
+        # dm should be equivalent to a nevermatcher.
+        self.assertEqual(dm.visitchildrenset('.'), set())
+        self.assertEqual(dm.visitchildrenset('dir'), set())
+        self.assertEqual(dm.visitchildrenset('dir/subdir'), set())
+        self.assertEqual(dm.visitchildrenset('dir/subdir/z'), set())
+        self.assertEqual(dm.visitchildrenset('dir/foo'), set())
+        self.assertEqual(dm.visitchildrenset('dir/subdir/x'), set())
+        self.assertEqual(dm.visitchildrenset('folder'), set())
+
     def testVisitdirM2never(self):
         m1 = matchmod.alwaysmatcher('', '')
         m2 = matchmod.nevermatcher('', '')
@@ -149,6 +250,19 @@ 
         self.assertEqual(dm.visitdir('dir/subdir/x'), True)
         self.assertEqual(dm.visitdir('folder'), True)
 
+    def testVisitchildrensetM2never(self):
+        m1 = matchmod.alwaysmatcher('', '')
+        m2 = matchmod.nevermatcher('', '')
+        dm = matchmod.differencematcher(m1, m2)
+        # dm should be equivalent to a alwaysmatcher.
+        self.assertEqual(dm.visitchildrenset('.'), 'all')
+        self.assertEqual(dm.visitchildrenset('dir'), 'all')
+        self.assertEqual(dm.visitchildrenset('dir/subdir'), 'all')
+        self.assertEqual(dm.visitchildrenset('dir/subdir/z'), 'all')
+        self.assertEqual(dm.visitchildrenset('dir/foo'), 'all')
+        self.assertEqual(dm.visitchildrenset('dir/subdir/x'), 'all')
+        self.assertEqual(dm.visitchildrenset('folder'), 'all')
+
     def testVisitdirM2SubdirPrefix(self):
         m1 = matchmod.alwaysmatcher('', '')
         m2 = matchmod.match('', '', patterns=['path:dir/subdir'])
@@ -165,6 +279,21 @@ 
         self.assertEqual(dm.visitdir('dir/foo'), True)
         self.assertEqual(dm.visitdir('folder'), True)
 
+    def testVisitchildrensetM2SubdirPrefix(self):
+        m1 = matchmod.alwaysmatcher('', '')
+        m2 = matchmod.match('', '', patterns=['path:dir/subdir'])
+        dm = matchmod.differencematcher(m1, m2)
+        self.assertEqual(dm.visitchildrenset('.'), 'this')
+        self.assertEqual(dm.visitchildrenset('dir'), 'this')
+        self.assertEqual(dm.visitchildrenset('dir/subdir'), set())
+        self.assertEqual(dm.visitchildrenset('dir/foo'), 'all')
+        self.assertEqual(dm.visitchildrenset('folder'), 'all')
+        # OPT: We should probably return set() for these; we don't because
+        # patternmatcher.visitdir() (our m2) doesn't return 'all' for subdirs of
+        # an 'all' pattern, just 'this'.
+        self.assertEqual(dm.visitchildrenset('dir/subdir/z'), 'this')
+        self.assertEqual(dm.visitchildrenset('dir/subdir/x'), 'this')
+
     # We're using includematcher instead of patterns because it behaves slightly
     # better (giving narrower results) than patternmatcher.
     def testVisitdirIncludeIncludfe(self):
@@ -182,6 +311,21 @@ 
         self.assertEqual(dm.visitdir('dir/subdir/z'), True)
         self.assertEqual(dm.visitdir('dir/subdir/x'), True)
 
+    def testVisitchildrensetIncludeInclude(self):
+        m1 = matchmod.match('', '', include=['path:dir/subdir'])
+        m2 = matchmod.match('', '', include=['rootfilesin:dir'])
+        dm = matchmod.differencematcher(m1, m2)
+        self.assertEqual(dm.visitchildrenset('.'), {'dir'})
+        self.assertEqual(dm.visitchildrenset('dir'), {'subdir'})
+        self.assertEqual(dm.visitchildrenset('dir/subdir'), 'all')
+        self.assertEqual(dm.visitchildrenset('dir/foo'), set())
+        self.assertEqual(dm.visitchildrenset('folder'), set())
+        # OPT: We should probably return set() for these; we don't because
+        # patternmatcher.visitdir() (our m2) doesn't return 'all' for subdirs of
+        # an 'all' pattern, just 'this'.
+        self.assertEqual(dm.visitchildrenset('dir/subdir/z'), 'this')
+        self.assertEqual(dm.visitchildrenset('dir/subdir/x'), 'this')
+
 class IntersectionMatcherTests(unittest.TestCase):
 
     def testVisitdirM2always(self):
@@ -197,6 +341,19 @@ 
         self.assertEqual(im.visitdir('dir/subdir/x'), 'all')
         self.assertEqual(im.visitdir('folder'), 'all')
 
+    def testVisitchildrensetM2always(self):
+        m1 = matchmod.alwaysmatcher('', '')
+        m2 = matchmod.alwaysmatcher('', '')
+        im = matchmod.intersectmatchers(m1, m2)
+        # im should be equivalent to a alwaysmatcher.
+        self.assertEqual(im.visitchildrenset('.'), 'all')
+        self.assertEqual(im.visitchildrenset('dir'), 'all')
+        self.assertEqual(im.visitchildrenset('dir/subdir'), 'all')
+        self.assertEqual(im.visitchildrenset('dir/subdir/z'), 'all')
+        self.assertEqual(im.visitchildrenset('dir/foo'), 'all')
+        self.assertEqual(im.visitchildrenset('dir/subdir/x'), 'all')
+        self.assertEqual(im.visitchildrenset('folder'), 'all')
+
     def testVisitdirM2never(self):
         m1 = matchmod.alwaysmatcher('', '')
         m2 = matchmod.nevermatcher('', '')
@@ -210,6 +367,19 @@ 
         self.assertFalse(im.visitdir('dir/subdir/x'))
         self.assertFalse(im.visitdir('folder'))
 
+    def testVisitchildrensetM2never(self):
+        m1 = matchmod.alwaysmatcher('', '')
+        m2 = matchmod.nevermatcher('', '')
+        im = matchmod.intersectmatchers(m1, m2)
+        # im should be equivalent to a nevermqtcher.
+        self.assertEqual(im.visitchildrenset('.'), set())
+        self.assertEqual(im.visitchildrenset('dir'), set())
+        self.assertEqual(im.visitchildrenset('dir/subdir'), set())
+        self.assertEqual(im.visitchildrenset('dir/subdir/z'), set())
+        self.assertEqual(im.visitchildrenset('dir/foo'), set())
+        self.assertEqual(im.visitchildrenset('dir/subdir/x'), set())
+        self.assertEqual(im.visitchildrenset('folder'), set())
+
     def testVisitdirM2SubdirPrefix(self):
         m1 = matchmod.alwaysmatcher('', '')
         m2 = matchmod.match('', '', patterns=['path:dir/subdir'])
@@ -225,6 +395,19 @@ 
         self.assertEqual(im.visitdir('dir/subdir/z'), True)
         self.assertEqual(im.visitdir('dir/subdir/x'), True)
 
+    def testVisitchildrensetM2SubdirPrefix(self):
+        m1 = matchmod.alwaysmatcher('', '')
+        m2 = matchmod.match('', '', include=['path:dir/subdir'])
+        im = matchmod.intersectmatchers(m1, m2)
+        self.assertEqual(im.visitchildrenset('.'), {'dir'})
+        self.assertEqual(im.visitchildrenset('dir'), {'subdir'})
+        self.assertEqual(im.visitchildrenset('dir/subdir'), 'all')
+        self.assertEqual(im.visitchildrenset('dir/foo'), set())
+        self.assertEqual(im.visitchildrenset('folder'), set())
+        # OPT: We should probably return 'all' for these
+        self.assertEqual(im.visitchildrenset('dir/subdir/z'), 'this')
+        self.assertEqual(im.visitchildrenset('dir/subdir/x'), 'this')
+
     # We're using includematcher instead of patterns because it behaves slightly
     # better (giving narrower results) than patternmatcher.
     def testVisitdirIncludeIncludfe(self):
@@ -239,6 +422,18 @@ 
         self.assertFalse(im.visitdir('dir/subdir/z'))
         self.assertFalse(im.visitdir('dir/subdir/x'))
 
+    def testVisitchildrensetIncludeInclude(self):
+        m1 = matchmod.match('', '', include=['path:dir/subdir'])
+        m2 = matchmod.match('', '', include=['rootfilesin:dir'])
+        im = matchmod.intersectmatchers(m1, m2)
+        self.assertEqual(im.visitchildrenset('.'), {'dir'})
+        self.assertEqual(im.visitchildrenset('dir'), 'this')
+        self.assertEqual(im.visitchildrenset('dir/subdir'), set())
+        self.assertEqual(im.visitchildrenset('dir/foo'), set())
+        self.assertEqual(im.visitchildrenset('folder'), set())
+        self.assertEqual(im.visitchildrenset('dir/subdir/z'), set())
+        self.assertEqual(im.visitchildrenset('dir/subdir/x'), set())
+
     # We're using includematcher instead of patterns because it behaves slightly
     # better (giving narrower results) than patternmatcher.
     def testVisitdirIncludeInclude2(self):
@@ -254,6 +449,19 @@ 
         self.assertFalse(im.visitdir('dir/subdir/z'))
         self.assertFalse(im.visitdir('dir/subdir/x'))
 
+    def testVisitchildrensetIncludeInclude2(self):
+        m1 = matchmod.match('', '', include=['path:dir/subdir'])
+        m2 = matchmod.match('', '', include=['path:folder'])
+        im = matchmod.intersectmatchers(m1, m2)
+        # FIXME: is set() correct here?
+        self.assertEqual(im.visitchildrenset('.'), set())
+        self.assertEqual(im.visitchildrenset('dir'), set())
+        self.assertEqual(im.visitchildrenset('dir/subdir'), set())
+        self.assertEqual(im.visitchildrenset('dir/foo'), set())
+        self.assertEqual(im.visitchildrenset('folder'), set())
+        self.assertEqual(im.visitchildrenset('dir/subdir/z'), set())
+        self.assertEqual(im.visitchildrenset('dir/subdir/x'), set())
+
     # We're using includematcher instead of patterns because it behaves slightly
     # better (giving narrower results) than patternmatcher.
     def testVisitdirIncludeInclude3(self):
@@ -269,6 +477,19 @@ 
         # OPT: this should probably be 'all' not True.
         self.assertEqual(im.visitdir('dir/subdir/x'), True)
 
+    def testVisitchildrensetIncludeInclude3(self):
+        m1 = matchmod.match('', '', include=['path:dir/subdir/x'])
+        m2 = matchmod.match('', '', include=['path:dir/subdir'])
+        im = matchmod.intersectmatchers(m1, m2)
+        self.assertEqual(im.visitchildrenset('.'), {'dir'})
+        self.assertEqual(im.visitchildrenset('dir'), {'subdir'})
+        self.assertEqual(im.visitchildrenset('dir/subdir'), {'x'})
+        self.assertEqual(im.visitchildrenset('dir/foo'), set())
+        self.assertEqual(im.visitchildrenset('folder'), set())
+        self.assertEqual(im.visitchildrenset('dir/subdir/z'), set())
+        # OPT: this should probably be 'all' not 'this'.
+        self.assertEqual(im.visitchildrenset('dir/subdir/x'), 'this')
+
     # We're using includematcher instead of patterns because it behaves slightly
     # better (giving narrower results) than patternmatcher.
     def testVisitdirIncludeInclude4(self):
@@ -284,6 +505,19 @@ 
         self.assertFalse(im.visitdir('dir/subdir/z'))
         self.assertFalse(im.visitdir('dir/subdir/x'))
 
+    def testVisitchildrensetIncludeInclude4(self):
+        m1 = matchmod.match('', '', include=['path:dir/subdir/x'])
+        m2 = matchmod.match('', '', include=['path:dir/subdir/z'])
+        im = matchmod.intersectmatchers(m1, m2)
+        # OPT: these next two could probably be set() as well.
+        self.assertEqual(im.visitchildrenset('.'), {'dir'})
+        self.assertEqual(im.visitchildrenset('dir'), {'subdir'})
+        self.assertEqual(im.visitchildrenset('dir/subdir'), set())
+        self.assertEqual(im.visitchildrenset('dir/foo'), set())
+        self.assertEqual(im.visitchildrenset('folder'), set())
+        self.assertEqual(im.visitchildrenset('dir/subdir/z'), set())
+        self.assertEqual(im.visitchildrenset('dir/subdir/x'), set())
+
 class UnionMatcherTests(unittest.TestCase):
 
     def testVisitdirM2always(self):
@@ -299,6 +533,19 @@ 
         self.assertEqual(um.visitdir('dir/subdir/x'), 'all')
         self.assertEqual(um.visitdir('folder'), 'all')
 
+    def testVisitchildrensetM2always(self):
+        m1 = matchmod.alwaysmatcher('', '')
+        m2 = matchmod.alwaysmatcher('', '')
+        um = matchmod.unionmatcher([m1, m2])
+        # um should be equivalent to a alwaysmatcher.
+        self.assertEqual(um.visitchildrenset('.'), 'all')
+        self.assertEqual(um.visitchildrenset('dir'), 'all')
+        self.assertEqual(um.visitchildrenset('dir/subdir'), 'all')
+        self.assertEqual(um.visitchildrenset('dir/subdir/z'), 'all')
+        self.assertEqual(um.visitchildrenset('dir/foo'), 'all')
+        self.assertEqual(um.visitchildrenset('dir/subdir/x'), 'all')
+        self.assertEqual(um.visitchildrenset('folder'), 'all')
+
     def testVisitdirM1never(self):
         m1 = matchmod.nevermatcher('', '')
         m2 = matchmod.alwaysmatcher('', '')
@@ -312,6 +559,19 @@ 
         self.assertEqual(um.visitdir('dir/subdir/x'), 'all')
         self.assertEqual(um.visitdir('folder'), 'all')
 
+    def testVisitchildrensetM1never(self):
+        m1 = matchmod.nevermatcher('', '')
+        m2 = matchmod.alwaysmatcher('', '')
+        um = matchmod.unionmatcher([m1, m2])
+        # um should be equivalent to a alwaysmatcher.
+        self.assertEqual(um.visitchildrenset('.'), 'all')
+        self.assertEqual(um.visitchildrenset('dir'), 'all')
+        self.assertEqual(um.visitchildrenset('dir/subdir'), 'all')
+        self.assertEqual(um.visitchildrenset('dir/subdir/z'), 'all')
+        self.assertEqual(um.visitchildrenset('dir/foo'), 'all')
+        self.assertEqual(um.visitchildrenset('dir/subdir/x'), 'all')
+        self.assertEqual(um.visitchildrenset('folder'), 'all')
+
     def testVisitdirM2never(self):
         m1 = matchmod.alwaysmatcher('', '')
         m2 = matchmod.nevermatcher('', '')
@@ -325,6 +585,19 @@ 
         self.assertEqual(um.visitdir('dir/subdir/x'), 'all')
         self.assertEqual(um.visitdir('folder'), 'all')
 
+    def testVisitchildrensetM2never(self):
+        m1 = matchmod.alwaysmatcher('', '')
+        m2 = matchmod.nevermatcher('', '')
+        um = matchmod.unionmatcher([m1, m2])
+        # um should be equivalent to a alwaysmatcher.
+        self.assertEqual(um.visitchildrenset('.'), 'all')
+        self.assertEqual(um.visitchildrenset('dir'), 'all')
+        self.assertEqual(um.visitchildrenset('dir/subdir'), 'all')
+        self.assertEqual(um.visitchildrenset('dir/subdir/z'), 'all')
+        self.assertEqual(um.visitchildrenset('dir/foo'), 'all')
+        self.assertEqual(um.visitchildrenset('dir/subdir/x'), 'all')
+        self.assertEqual(um.visitchildrenset('folder'), 'all')
+
     def testVisitdirM2SubdirPrefix(self):
         m1 = matchmod.alwaysmatcher('', '')
         m2 = matchmod.match('', '', patterns=['path:dir/subdir'])
@@ -337,6 +610,18 @@ 
         self.assertEqual(um.visitdir('dir/subdir/z'), 'all')
         self.assertEqual(um.visitdir('dir/subdir/x'), 'all')
 
+    def testVisitchildrensetM2SubdirPrefix(self):
+        m1 = matchmod.alwaysmatcher('', '')
+        m2 = matchmod.match('', '', include=['path:dir/subdir'])
+        um = matchmod.unionmatcher([m1, m2])
+        self.assertEqual(um.visitchildrenset('.'), 'all')
+        self.assertEqual(um.visitchildrenset('dir'), 'all')
+        self.assertEqual(um.visitchildrenset('dir/subdir'), 'all')
+        self.assertEqual(um.visitchildrenset('dir/foo'), 'all')
+        self.assertEqual(um.visitchildrenset('folder'), 'all')
+        self.assertEqual(um.visitchildrenset('dir/subdir/z'), 'all')
+        self.assertEqual(um.visitchildrenset('dir/subdir/x'), 'all')
+
     # We're using includematcher instead of patterns because it behaves slightly
     # better (giving narrower results) than patternmatcher.
     def testVisitdirIncludeIncludfe(self):
@@ -352,6 +637,19 @@ 
         self.assertEqual(um.visitdir('dir/subdir/z'), True)
         self.assertEqual(um.visitdir('dir/subdir/x'), True)
 
+    def testVisitchildrensetIncludeInclude(self):
+        m1 = matchmod.match('', '', include=['path:dir/subdir'])
+        m2 = matchmod.match('', '', include=['rootfilesin:dir'])
+        um = matchmod.unionmatcher([m1, m2])
+        self.assertEqual(um.visitchildrenset('.'), {'dir'})
+        self.assertEqual(um.visitchildrenset('dir'), 'this')
+        self.assertEqual(um.visitchildrenset('dir/subdir'), 'all')
+        self.assertEqual(um.visitchildrenset('dir/foo'), set())
+        self.assertEqual(um.visitchildrenset('folder'), set())
+        # OPT: These next two could be 'all' instead of 'this'.
+        self.assertEqual(um.visitchildrenset('dir/subdir/z'), 'this')
+        self.assertEqual(um.visitchildrenset('dir/subdir/x'), 'this')
+
     # We're using includematcher instead of patterns because it behaves slightly
     # better (giving narrower results) than patternmatcher.
     def testVisitdirIncludeInclude2(self):
@@ -367,6 +665,19 @@ 
         self.assertEqual(um.visitdir('dir/subdir/z'), True)
         self.assertEqual(um.visitdir('dir/subdir/x'), True)
 
+    def testVisitchildrensetIncludeInclude2(self):
+        m1 = matchmod.match('', '', include=['path:dir/subdir'])
+        m2 = matchmod.match('', '', include=['path:folder'])
+        um = matchmod.unionmatcher([m1, m2])
+        self.assertEqual(um.visitchildrenset('.'), {'folder', 'dir'})
+        self.assertEqual(um.visitchildrenset('dir'), {'subdir'})
+        self.assertEqual(um.visitchildrenset('dir/subdir'), 'all')
+        self.assertEqual(um.visitchildrenset('dir/foo'), set())
+        self.assertEqual(um.visitchildrenset('folder'), 'all')
+        # OPT: These next two could be 'all' instead of 'this'.
+        self.assertEqual(um.visitchildrenset('dir/subdir/z'), 'this')
+        self.assertEqual(um.visitchildrenset('dir/subdir/x'), 'this')
+
     # We're using includematcher instead of patterns because it behaves slightly
     # better (giving narrower results) than patternmatcher.
     def testVisitdirIncludeInclude3(self):
@@ -382,6 +693,19 @@ 
         # OPT: this should probably be 'all' not True.
         self.assertEqual(um.visitdir('dir/subdir/z'), True)
 
+    def testVisitchildrensetIncludeInclude3(self):
+        m1 = matchmod.match('', '', include=['path:dir/subdir/x'])
+        m2 = matchmod.match('', '', include=['path:dir/subdir'])
+        um = matchmod.unionmatcher([m1, m2])
+        self.assertEqual(um.visitchildrenset('.'), {'dir'})
+        self.assertEqual(um.visitchildrenset('dir'), {'subdir'})
+        self.assertEqual(um.visitchildrenset('dir/subdir'), 'all')
+        self.assertEqual(um.visitchildrenset('dir/foo'), set())
+        self.assertEqual(um.visitchildrenset('folder'), set())
+        self.assertEqual(um.visitchildrenset('dir/subdir/x'), 'all')
+        # OPT: this should probably be 'all' not 'this'.
+        self.assertEqual(um.visitchildrenset('dir/subdir/z'), 'this')
+
     # We're using includematcher instead of patterns because it behaves slightly
     # better (giving narrower results) than patternmatcher.
     def testVisitdirIncludeInclude4(self):
@@ -397,6 +721,18 @@ 
         self.assertEqual(um.visitdir('dir/subdir/z'), 'all')
         self.assertEqual(um.visitdir('dir/subdir/x'), 'all')
 
+    def testVisitchildrensetIncludeInclude4(self):
+        m1 = matchmod.match('', '', include=['path:dir/subdir/x'])
+        m2 = matchmod.match('', '', include=['path:dir/subdir/z'])
+        um = matchmod.unionmatcher([m1, m2])
+        self.assertEqual(um.visitchildrenset('.'), {'dir'})
+        self.assertEqual(um.visitchildrenset('dir'), {'subdir'})
+        self.assertEqual(um.visitchildrenset('dir/subdir'), {'x', 'z'})
+        self.assertEqual(um.visitchildrenset('dir/foo'), set())
+        self.assertEqual(um.visitchildrenset('folder'), set())
+        self.assertEqual(um.visitchildrenset('dir/subdir/z'), 'all')
+        self.assertEqual(um.visitchildrenset('dir/subdir/x'), 'all')
+
 class SubdirMatcherTests(unittest.TestCase):
 
     def testVisitdir(self):
@@ -410,6 +746,17 @@ 
         self.assertEqual(sm.visitdir('subdir/z'), True)
         self.assertFalse(sm.visitdir('foo'))
 
+    def testVisitchildrenset(self):
+        m = matchmod.match('', '', include=['path:dir/subdir'])
+        sm = matchmod.subdirmatcher('dir', m)
+
+        self.assertEqual(sm.visitchildrenset('.'), {'subdir'})
+        self.assertEqual(sm.visitchildrenset('subdir'), 'all')
+        # OPT: These next two should probably be 'all' not 'this'.
+        self.assertEqual(sm.visitchildrenset('subdir/x'), 'this')
+        self.assertEqual(sm.visitchildrenset('subdir/z'), 'this')
+        self.assertEqual(sm.visitchildrenset('foo'), set())
+
 class PrefixdirMatcherTests(unittest.TestCase):
 
     def testVisitdir(self):
@@ -444,5 +791,27 @@ 
         self.assertEqual(pm.visitdir('d/e/f'), True)
         self.assertEqual(pm.visitdir('d/e/f/g'), False)
 
+    def testVisitchildrenset(self):
+        m = matchmod.match(util.localpath('root/d'), 'e/f',
+                ['../a.txt', 'b.txt'])
+        pm = matchmod.prefixdirmatcher('root', 'd/e/f', 'd', m)
+
+        # OPT: visitchildrenset could possibly return {'e'} and {'f'} for these
+        # next two, respectively; patternmatcher does not have this
+        # optimization.
+        self.assertEqual(m.visitchildrenset('.'), 'this')
+        self.assertEqual(m.visitchildrenset('e'), 'this')
+        self.assertEqual(m.visitchildrenset('e/f'), 'this')
+        self.assertEqual(m.visitchildrenset('e/f/g'), set())
+
+        # OPT: visitchildrenset could possibly return {'d'}, {'e'}, and {'f'}
+        # for these next three, respectively; patternmatcher does not have this
+        # optimization.
+        self.assertEqual(pm.visitchildrenset('.'), 'this')
+        self.assertEqual(pm.visitchildrenset('d'), 'this')
+        self.assertEqual(pm.visitchildrenset('d/e'), 'this')
+        self.assertEqual(pm.visitchildrenset('d/e/f'), 'this')
+        self.assertEqual(pm.visitchildrenset('d/e/f/g'), set())
+
 if __name__ == '__main__':
     silenttestrunner.main(__name__)
diff --git a/mercurial/match.py b/mercurial/match.py
--- a/mercurial/match.py
+++ b/mercurial/match.py
@@ -8,6 +8,7 @@ 
 from __future__ import absolute_import, print_function
 
 import copy
+import itertools
 import os
 import re
 
@@ -331,6 +332,38 @@ 
         '''
         return True
 
+    def visitchildrenset(self, dir):
+        '''Decides whether a directory should be visited based on whether it
+        has potential matches in it or one of its subdirectories, and
+        potentially lists which subdirectories of that directory should be
+        visited. This is based on the match's primary, included, and excluded
+        patterns.
+
+        This function is very similar to 'visitdir', and the following mapping
+        can be applied:
+
+             visitdir | visitchildrenlist
+            ----------+-------------------
+             False    | set()
+             'all'    | 'all'
+             True     | 'this' OR non-empty set of subdirs to visit
+
+        Example:
+          Assume matchers ['path:foo/bar', 'rootfilesin:qux'], we would return
+          the following values (assuming the implementation of visitchildrenset
+          is capable of recognizing this; some implementations are not).
+
+          '.' -> {'foo', 'qux'}
+          'baz' -> set()
+          'foo' -> {'bar'}
+          # Ideally this would be 'all', but since the prefix nature of matchers
+          # is applied to the entire matcher, we have to downgrade to this
+          # 'this' due to the non-prefix 'rootfilesin'-kind matcher.
+          'foo/bar' -> 'this'
+          'qux' -> 'this'
+        '''
+        return 'this'
+
     def always(self):
         '''Matcher will match everything and .files() will be empty --
         optimization might be possible.'''
@@ -367,6 +400,9 @@ 
     def visitdir(self, dir):
         return 'all'
 
+    def visitchildrenset(self, dir):
+        return 'all'
+
     def __repr__(self):
         return r'<alwaysmatcher>'
 
@@ -390,6 +426,9 @@ 
     def visitdir(self, dir):
         return False
 
+    def visitchildrenset(self, dir):
+        return set()
+
     def __repr__(self):
         return r'<nevermatcher>'
 
@@ -430,6 +469,15 @@ 
                 any(parentdir in self._fileset
                     for parentdir in util.finddirs(dir)))
 
+    def visitchildrenset(self, dir):
+        ret = self.visitdir(dir)
+        if ret is True:
+            return 'this'
+        elif not ret:
+            return set()
+        assert ret == 'all'
+        return 'all'
+
     def prefix(self):
         return self._prefix
 
@@ -464,6 +512,43 @@ 
                 any(parentdir in self._roots
                     for parentdir in util.finddirs(dir)))
 
+    def visitchildrenset(self, dir):
+        if self._prefix and dir in self._roots:
+            return 'all'
+        # Note: this does *not* include the 'dir in self._parents' case from
+        # visitdir, that's handled below.
+        if ('.' in self._roots or
+            dir in self._roots or
+            dir in self._dirs or
+            any(parentdir in self._roots
+                for parentdir in util.finddirs(dir))):
+            return 'this'
+
+        ret = set()
+        if dir in self._parents:
+            # We add a '/' on to `dir` so that we don't return items that are
+            # prefixed by `dir` but are actually siblings of `dir`.
+            suffixeddir = dir + '/' if dir != '.' else ''
+            # Look in all _roots, _dirs, and _parents for things that start with
+            # 'suffixeddir'.
+            for d in [q for q in
+                      itertools.chain(self._roots, self._dirs, self._parents) if
+                      q.startswith(suffixeddir)]:
+                # Don't emit '.' in the response for the root directory
+                if not suffixeddir and d == '.':
+                    continue
+
+                # We return the item name without the `suffixeddir` prefix or a
+                # slash suffix
+                d = d[len(suffixeddir):]
+                if '/' in d:
+                    # This is a subdirectory-of-a-subdirectory, i.e.
+                    # suffixeddir='foo/', d was 'foo/bar/baz' before removing
+                    # 'foo/'.
+                    d = d[:d.index('/')]
+                ret.add(d)
+        return ret
+
     @encoding.strmethod
     def __repr__(self):
         return ('<includematcher includes=%r>' % pycompat.bytestr(self._pats))
@@ -490,6 +575,25 @@ 
     def visitdir(self, dir):
         return dir in self._dirs
 
+    def visitchildrenset(self, dir):
+        if dir in self._dirs:
+            candidates = self._dirs - {'.'}
+            if dir != '.':
+                d = dir + '/'
+                candidates = set(c[len(d):] for c in candidates if
+                                 c.startswith(d))
+            # self._dirs includes all of the directories, recursively, so if
+            # we're attempting to match foo/bar/baz.txt, it'll have '.', 'foo',
+            # 'foo/bar' in it. Thus we can safely ignore a candidate that has a
+            # '/' in it, indicating a it's for a subdir-of-a-subdir; the
+            # immediate subdir will be in there without a slash.
+            ret = set(c for c in candidates if '/' not in c)
+            # We need to emit 'this' for foo/bar, not set(), not {'baz.txt'}.
+            if not ret:
+                return 'this'
+            return ret
+        return set()
+
     def isexact(self):
         return True
 
@@ -531,6 +635,31 @@ 
             return False
         return bool(self._m1.visitdir(dir))
 
+    def visitchildrenset(self, dir):
+        m2_set = self._m2.visitchildrenset(dir)
+        if m2_set == 'all':
+            return set()
+        m1_set = self._m1.visitchildrenset(dir)
+        # Possible values for m1: 'all', 'this', set(...), set()
+        # Possible values for m2:        'this', set(...), set()
+        # If m2 has nothing under here that we care about, return m1, even if
+        # it's 'all'. This is a change in behavior from visitdir, which would
+        # return True, not 'all', for some reason.
+        if not m2_set:
+            return m1_set
+        if m1_set in ['all', 'this']:
+            # Never return 'all' here if m2_set is any kind of non-empty (either
+            # 'this' or set(foo)), since m2 might return set() for a
+            # subdirectory.
+            return 'this'
+        # Possible values for m1:         set(...), set()
+        # Possible values for m2: 'this', set(...)
+        # We ignore m2's set results. They're possibly incorrect:
+        #  m1 = path:dir/subdir, m2=rootfilesin:dir, visitchildrenset('.'):
+        #    m1 returns {'dir'}, m2 returns {'dir'}, if we subtracted we'd
+        #    return set(), which is *not* correct, we still need to visit 'dir'!
+        return m1_set
+
     def isexact(self):
         return self._m1.isexact()
 
@@ -595,6 +724,25 @@ 
         # bool() because visit1=True + visit2='all' should not be 'all'
         return bool(visit1 and self._m2.visitdir(dir))
 
+    def visitchildrenset(self, dir):
+        m1_set = self._m1.visitchildrenset(dir)
+        if not m1_set:
+            return set()
+        m2_set = self._m2.visitchildrenset(dir)
+        if not m2_set:
+            return set()
+
+        if m1_set == 'all':
+            return m2_set
+        elif m2_set == 'all':
+            return m1_set
+
+        if m1_set == 'this' or m2_set == 'this':
+            return 'this'
+
+        assert isinstance(m1_set, set) and isinstance(m2_set, set)
+        return m1_set.intersection(m2_set)
+
     def always(self):
         return self._m1.always() and self._m2.always()
 
@@ -676,6 +824,13 @@ 
             dir = self._path + "/" + dir
         return self._matcher.visitdir(dir)
 
+    def visitchildrenset(self, dir):
+        if dir == '.':
+            dir = self._path
+        else:
+            dir = self._path + "/" + dir
+        return self._matcher.visitchildrenset(dir)
+
     def always(self):
         return self._always
 
@@ -748,6 +903,14 @@ 
             return self._matcher.visitdir(dir[len(self._pathprefix):])
         return dir in self._pathdirs
 
+    def visitchildrenset(self, dir):
+        if dir == self._path:
+            return self._matcher.visitchildrenset('.')
+        if dir.startswith(self._pathprefix):
+            return self._matcher.visitchildrenset(dir[len(self._pathprefix):])
+        if dir in self._pathdirs:
+            return 'this'
+
     def isexact(self):
         return self._matcher.isexact()
 
@@ -788,6 +951,25 @@ 
             r |= v
         return r
 
+    def visitchildrenset(self, dir):
+        r = set()
+        this = False
+        for m in self._matchers:
+            v = m.visitchildrenset(dir)
+            if not v:
+                continue
+            if v == 'all':
+                return v
+            if this or v == 'this':
+                this = True
+                # don't break, we might have an 'all' in here.
+                continue
+            assert isinstance(v, set)
+            r = r.union(v)
+        if this:
+            return 'this'
+        return r
+
     @encoding.strmethod
     def __repr__(self):
         return ('<unionmatcher matchers=%r>' % self._matchers)