fileset: insert hints where status should be computed

This will allow us to compute status against a narrowed set of files.
For example, "path:build/ & (unknown() + missing())" is rewritten as
"path:build/ & <withstatus>(unknown() + missing(), 'unknown missing')",
and the status call can be narrowed by the left-hand-side matcher,
"path:build/".

mctx.buildstatus() calls will be solely processed by getmatchwithstatus().

mercurial/fileset.py

@@ -1,573 +1,577 b''
 # fileset.py - file set queries for mercurial
 #
 # Copyright 2010 Matt Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 from __future__ import absolute_import
 
 import errno
 import re
 
 from .i18n import _
 from . import (
     error,
     filesetlang,
     match as matchmod,
     merge,
     pycompat,
     registrar,
     scmutil,
     util,
 )
 from .utils import (
     stringutil,
 )
 
 # common weight constants
 _WEIGHT_CHECK_FILENAME = filesetlang.WEIGHT_CHECK_FILENAME
 _WEIGHT_READ_CONTENTS = filesetlang.WEIGHT_READ_CONTENTS
 _WEIGHT_STATUS = filesetlang.WEIGHT_STATUS
 _WEIGHT_STATUS_THOROUGH = filesetlang.WEIGHT_STATUS_THOROUGH
 
 # helpers for processing parsed tree
 getsymbol = filesetlang.getsymbol
 getstring = filesetlang.getstring
 _getkindpat = filesetlang.getkindpat
 getpattern = filesetlang.getpattern
 getargs = filesetlang.getargs
 
 def getmatch(mctx, x):
     if not x:
         raise error.ParseError(_("missing argument"))
     return methods[x[0]](mctx, *x[1:])
 
+def getmatchwithstatus(mctx, x, hint):
+    return getmatch(mctx, x)
+
 def stringmatch(mctx, x):
     return mctx.matcher([x])
 
 def kindpatmatch(mctx, x, y):
     return stringmatch(mctx, _getkindpat(x, y, matchmod.allpatternkinds,
                                          _("pattern must be a string")))
 
 def patternsmatch(mctx, *xs):
     allkinds = matchmod.allpatternkinds
     patterns = [getpattern(x, allkinds, _("pattern must be a string"))
                 for x in xs]
     return mctx.matcher(patterns)
 
 def andmatch(mctx, x, y):
     xm = getmatch(mctx, x)
     ym = getmatch(mctx, y)
     return matchmod.intersectmatchers(xm, ym)
 
 def ormatch(mctx, *xs):
     ms = [getmatch(mctx, x) for x in xs]
     return matchmod.unionmatcher(ms)
 
 def notmatch(mctx, x):
     m = getmatch(mctx, x)
     return mctx.predicate(lambda f: not m(f), predrepr=('<not %r>', m))
 
 def minusmatch(mctx, x, y):
     xm = getmatch(mctx, x)
     ym = getmatch(mctx, y)
     return matchmod.differencematcher(xm, ym)
 
 def listmatch(mctx, *xs):
     raise error.ParseError(_("can't use a list in this context"),
                            hint=_('see \'hg help "filesets.x or y"\''))
 
 def func(mctx, a, b):
     funcname = getsymbol(a)
     if funcname in symbols:
         return symbols[funcname](mctx, b)
 
     keep = lambda fn: getattr(fn, '__doc__', None) is not None
 
     syms = [s for (s, fn) in symbols.items() if keep(fn)]
     raise error.UnknownIdentifier(funcname, syms)
 
 # symbols are callable like:
 #  fun(mctx, x)
 # with:
 #  mctx - current matchctx instance
 #  x - argument in tree form
 symbols = filesetlang.symbols
 
 # filesets using matchctx.status()
 _statuscallers = set()
 
 predicate = registrar.filesetpredicate()
 
 @predicate('modified()', callstatus=True, weight=_WEIGHT_STATUS)
 def modified(mctx, x):
     """File that is modified according to :hg:`status`.
     """
     # i18n: "modified" is a keyword
     getargs(x, 0, 0, _("modified takes no arguments"))
     s = set(mctx.status().modified)
     return mctx.predicate(s.__contains__, predrepr='modified')
 
 @predicate('added()', callstatus=True, weight=_WEIGHT_STATUS)
 def added(mctx, x):
     """File that is added according to :hg:`status`.
     """
     # i18n: "added" is a keyword
     getargs(x, 0, 0, _("added takes no arguments"))
     s = set(mctx.status().added)
     return mctx.predicate(s.__contains__, predrepr='added')
 
 @predicate('removed()', callstatus=True, weight=_WEIGHT_STATUS)
 def removed(mctx, x):
     """File that is removed according to :hg:`status`.
     """
     # i18n: "removed" is a keyword
     getargs(x, 0, 0, _("removed takes no arguments"))
     s = set(mctx.status().removed)
     return mctx.predicate(s.__contains__, predrepr='removed')
 
 @predicate('deleted()', callstatus=True, weight=_WEIGHT_STATUS)
 def deleted(mctx, x):
     """Alias for ``missing()``.
     """
     # i18n: "deleted" is a keyword
     getargs(x, 0, 0, _("deleted takes no arguments"))
     s = set(mctx.status().deleted)
     return mctx.predicate(s.__contains__, predrepr='deleted')
 
 @predicate('missing()', callstatus=True, weight=_WEIGHT_STATUS)
 def missing(mctx, x):
     """File that is missing according to :hg:`status`.
     """
     # i18n: "missing" is a keyword
     getargs(x, 0, 0, _("missing takes no arguments"))
     s = set(mctx.status().deleted)
     return mctx.predicate(s.__contains__, predrepr='deleted')
 
 @predicate('unknown()', callstatus=True, weight=_WEIGHT_STATUS_THOROUGH)
 def unknown(mctx, x):
     """File that is unknown according to :hg:`status`."""
     # i18n: "unknown" is a keyword
     getargs(x, 0, 0, _("unknown takes no arguments"))
     s = set(mctx.status().unknown)
     return mctx.predicate(s.__contains__, predrepr='unknown')
 
 @predicate('ignored()', callstatus=True, weight=_WEIGHT_STATUS_THOROUGH)
 def ignored(mctx, x):
     """File that is ignored according to :hg:`status`."""
     # i18n: "ignored" is a keyword
     getargs(x, 0, 0, _("ignored takes no arguments"))
     s = set(mctx.status().ignored)
     return mctx.predicate(s.__contains__, predrepr='ignored')
 
 @predicate('clean()', callstatus=True, weight=_WEIGHT_STATUS)
 def clean(mctx, x):
     """File that is clean according to :hg:`status`.
     """
     # i18n: "clean" is a keyword
     getargs(x, 0, 0, _("clean takes no arguments"))
     s = set(mctx.status().clean)
     return mctx.predicate(s.__contains__, predrepr='clean')
 
 @predicate('tracked()')
 def tracked(mctx, x):
     """File that is under Mercurial control."""
     # i18n: "tracked" is a keyword
     getargs(x, 0, 0, _("tracked takes no arguments"))
     return mctx.predicate(mctx.ctx.__contains__, predrepr='tracked')
 
 @predicate('binary()', weight=_WEIGHT_READ_CONTENTS)
 def binary(mctx, x):
     """File that appears to be binary (contains NUL bytes).
     """
     # i18n: "binary" is a keyword
     getargs(x, 0, 0, _("binary takes no arguments"))
     return mctx.fpredicate(lambda fctx: fctx.isbinary(),
                            predrepr='binary', cache=True)
 
 @predicate('exec()')
 def exec_(mctx, x):
     """File that is marked as executable.
     """
     # i18n: "exec" is a keyword
     getargs(x, 0, 0, _("exec takes no arguments"))
     ctx = mctx.ctx
     return mctx.predicate(lambda f: ctx.flags(f) == 'x', predrepr='exec')
 
 @predicate('symlink()')
 def symlink(mctx, x):
     """File that is marked as a symlink.
     """
     # i18n: "symlink" is a keyword
     getargs(x, 0, 0, _("symlink takes no arguments"))
     ctx = mctx.ctx
     return mctx.predicate(lambda f: ctx.flags(f) == 'l', predrepr='symlink')
 
 @predicate('resolved()', weight=_WEIGHT_STATUS)
 def resolved(mctx, x):
     """File that is marked resolved according to :hg:`resolve -l`.
     """
     # i18n: "resolved" is a keyword
     getargs(x, 0, 0, _("resolved takes no arguments"))
     if mctx.ctx.rev() is not None:
         return mctx.never()
     ms = merge.mergestate.read(mctx.ctx.repo())
     return mctx.predicate(lambda f: f in ms and ms[f] == 'r',
                           predrepr='resolved')
 
 @predicate('unresolved()', weight=_WEIGHT_STATUS)
 def unresolved(mctx, x):
     """File that is marked unresolved according to :hg:`resolve -l`.
     """
     # i18n: "unresolved" is a keyword
     getargs(x, 0, 0, _("unresolved takes no arguments"))
     if mctx.ctx.rev() is not None:
         return mctx.never()
     ms = merge.mergestate.read(mctx.ctx.repo())
     return mctx.predicate(lambda f: f in ms and ms[f] == 'u',
                           predrepr='unresolved')
 
 @predicate('hgignore()', weight=_WEIGHT_STATUS)
 def hgignore(mctx, x):
     """File that matches the active .hgignore pattern.
     """
     # i18n: "hgignore" is a keyword
     getargs(x, 0, 0, _("hgignore takes no arguments"))
     return mctx.ctx.repo().dirstate._ignore
 
 @predicate('portable()', weight=_WEIGHT_CHECK_FILENAME)
 def portable(mctx, x):
     """File that has a portable name. (This doesn't include filenames with case
     collisions.)
     """
     # i18n: "portable" is a keyword
     getargs(x, 0, 0, _("portable takes no arguments"))
     return mctx.predicate(lambda f: util.checkwinfilename(f) is None,
                           predrepr='portable')
 
 @predicate('grep(regex)', weight=_WEIGHT_READ_CONTENTS)
 def grep(mctx, x):
     """File contains the given regular expression.
     """
     try:
         # i18n: "grep" is a keyword
         r = re.compile(getstring(x, _("grep requires a pattern")))
     except re.error as e:
         raise error.ParseError(_('invalid match pattern: %s') %
                                stringutil.forcebytestr(e))
     return mctx.fpredicate(lambda fctx: r.search(fctx.data()),
                            predrepr=('grep(%r)', r.pattern), cache=True)
 
 def _sizetomax(s):
     try:
         s = s.strip().lower()
         for k, v in util._sizeunits:
             if s.endswith(k):
                 # max(4k) = 5k - 1, max(4.5k) = 4.6k - 1
                 n = s[:-len(k)]
                 inc = 1.0
                 if "." in n:
                     inc /= 10 ** len(n.split(".")[1])
                 return int((float(n) + inc) * v) - 1
         # no extension, this is a precise value
         return int(s)
     except ValueError:
         raise error.ParseError(_("couldn't parse size: %s") % s)
 
 def sizematcher(expr):
     """Return a function(size) -> bool from the ``size()`` expression"""
     expr = expr.strip()
     if '-' in expr: # do we have a range?
         a, b = expr.split('-', 1)
         a = util.sizetoint(a)
         b = util.sizetoint(b)
         return lambda x: x >= a and x <= b
     elif expr.startswith("<="):
         a = util.sizetoint(expr[2:])
         return lambda x: x <= a
     elif expr.startswith("<"):
         a = util.sizetoint(expr[1:])
         return lambda x: x < a
     elif expr.startswith(">="):
         a = util.sizetoint(expr[2:])
         return lambda x: x >= a
     elif expr.startswith(">"):
         a = util.sizetoint(expr[1:])
         return lambda x: x > a
     else:
         a = util.sizetoint(expr)
         b = _sizetomax(expr)
         return lambda x: x >= a and x <= b
 
 @predicate('size(expression)', weight=_WEIGHT_STATUS)
 def size(mctx, x):
     """File size matches the given expression. Examples:
 
     - size('1k') - files from 1024 to 2047 bytes
     - size('< 20k') - files less than 20480 bytes
     - size('>= .5MB') - files at least 524288 bytes
     - size('4k - 1MB') - files from 4096 bytes to 1048576 bytes
     """
     # i18n: "size" is a keyword
     expr = getstring(x, _("size requires an expression"))
     m = sizematcher(expr)
     return mctx.fpredicate(lambda fctx: m(fctx.size()),
                            predrepr=('size(%r)', expr), cache=True)
 
 @predicate('encoding(name)', weight=_WEIGHT_READ_CONTENTS)
 def encoding(mctx, x):
     """File can be successfully decoded with the given character
     encoding. May not be useful for encodings other than ASCII and
     UTF-8.
     """
 
     # i18n: "encoding" is a keyword
     enc = getstring(x, _("encoding requires an encoding name"))
 
     def encp(fctx):
         d = fctx.data()
         try:
             d.decode(pycompat.sysstr(enc))
             return True
         except LookupError:
             raise error.Abort(_("unknown encoding '%s'") % enc)
         except UnicodeDecodeError:
             return False
 
     return mctx.fpredicate(encp, predrepr=('encoding(%r)', enc), cache=True)
 
 @predicate('eol(style)', weight=_WEIGHT_READ_CONTENTS)
 def eol(mctx, x):
     """File contains newlines of the given style (dos, unix, mac). Binary
     files are excluded, files with mixed line endings match multiple
     styles.
     """
 
     # i18n: "eol" is a keyword
     enc = getstring(x, _("eol requires a style name"))
 
     def eolp(fctx):
         if fctx.isbinary():
             return False
         d = fctx.data()
         if (enc == 'dos' or enc == 'win') and '\r\n' in d:
             return True
         elif enc == 'unix' and re.search('(?<!\r)\n', d):
             return True
         elif enc == 'mac' and re.search('\r(?!\n)', d):
             return True
         return False
     return mctx.fpredicate(eolp, predrepr=('eol(%r)', enc), cache=True)
 
 @predicate('copied()')
 def copied(mctx, x):
     """File that is recorded as being copied.
     """
     # i18n: "copied" is a keyword
     getargs(x, 0, 0, _("copied takes no arguments"))
     def copiedp(fctx):
         p = fctx.parents()
         return p and p[0].path() != fctx.path()
     return mctx.fpredicate(copiedp, predrepr='copied', cache=True)
 
 @predicate('revs(revs, pattern)', weight=_WEIGHT_STATUS)
 def revs(mctx, x):
     """Evaluate set in the specified revisions. If the revset match multiple
     revs, this will return file matching pattern in any of the revision.
     """
     # i18n: "revs" is a keyword
     r, x = getargs(x, 2, 2, _("revs takes two arguments"))
     # i18n: "revs" is a keyword
     revspec = getstring(r, _("first argument to revs must be a revision"))
     repo = mctx.ctx.repo()
     revs = scmutil.revrange(repo, [revspec])
 
     matchers = []
     for r in revs:
         ctx = repo[r]
         mc = mctx.switch(ctx.p1(), ctx)
         mc.buildstatus(x)
         matchers.append(getmatch(mc, x))
     if not matchers:
         return mctx.never()
     if len(matchers) == 1:
         return matchers[0]
     return matchmod.unionmatcher(matchers)
 
 @predicate('status(base, rev, pattern)', weight=_WEIGHT_STATUS)
 def status(mctx, x):
     """Evaluate predicate using status change between ``base`` and
     ``rev``. Examples:
 
     - ``status(3, 7, added())`` - matches files added from "3" to "7"
     """
     repo = mctx.ctx.repo()
     # i18n: "status" is a keyword
     b, r, x = getargs(x, 3, 3, _("status takes three arguments"))
     # i18n: "status" is a keyword
     baseerr = _("first argument to status must be a revision")
     baserevspec = getstring(b, baseerr)
     if not baserevspec:
         raise error.ParseError(baseerr)
     reverr = _("second argument to status must be a revision")
     revspec = getstring(r, reverr)
     if not revspec:
         raise error.ParseError(reverr)
     basectx, ctx = scmutil.revpair(repo, [baserevspec, revspec])
     mc = mctx.switch(basectx, ctx)
     mc.buildstatus(x)
     return getmatch(mc, x)
 
 @predicate('subrepo([pattern])')
 def subrepo(mctx, x):
     """Subrepositories whose paths match the given pattern.
     """
     # i18n: "subrepo" is a keyword
     getargs(x, 0, 1, _("subrepo takes at most one argument"))
     ctx = mctx.ctx
     sstate = ctx.substate
     if x:
         pat = getpattern(x, matchmod.allpatternkinds,
                          # i18n: "subrepo" is a keyword
                          _("subrepo requires a pattern or no arguments"))
         fast = not matchmod.patkind(pat)
         if fast:
             def m(s):
                 return (s == pat)
         else:
             m = matchmod.match(ctx.repo().root, '', [pat], ctx=ctx)
         return mctx.predicate(lambda f: f in sstate and m(f),
                               predrepr=('subrepo(%r)', pat))
     else:
         return mctx.predicate(sstate.__contains__, predrepr='subrepo')
 
 methods = {
+    'withstatus': getmatchwithstatus,
     'string': stringmatch,
     'symbol': stringmatch,
     'kindpat': kindpatmatch,
     'patterns': patternsmatch,
     'and': andmatch,
     'or': ormatch,
     'minus': minusmatch,
     'list': listmatch,
     'not': notmatch,
     'func': func,
 }
 
 class matchctx(object):
     def __init__(self, basectx, ctx, badfn=None):
         self._basectx = basectx
         self.ctx = ctx
         self._badfn = badfn
         self._status = None
 
     def buildstatus(self, tree):
         if not _intree(_statuscallers, tree):
             return
         unknown = _intree(['unknown'], tree)
         ignored = _intree(['ignored'], tree)
         self._status = self._basectx.status(self.ctx,
                                             listignored=ignored,
                                             listclean=True,
                                             listunknown=unknown)
 
     def status(self):
         return self._status
 
     def matcher(self, patterns):
         return self.ctx.match(patterns, badfn=self._badfn)
 
     def predicate(self, predfn, predrepr=None, cache=False):
         """Create a matcher to select files by predfn(filename)"""
         if cache:
             predfn = util.cachefunc(predfn)
         repo = self.ctx.repo()
         return matchmod.predicatematcher(repo.root, repo.getcwd(), predfn,
                                          predrepr=predrepr, badfn=self._badfn)
 
     def fpredicate(self, predfn, predrepr=None, cache=False):
         """Create a matcher to select files by predfn(fctx) at the current
         revision
 
         Missing files are ignored.
         """
         ctx = self.ctx
         if ctx.rev() is None:
             def fctxpredfn(f):
                 try:
                     fctx = ctx[f]
                 except error.LookupError:
                     return False
                 try:
                     fctx.audit()
                 except error.Abort:
                     return False
                 try:
                     return predfn(fctx)
                 except (IOError, OSError) as e:
                     # open()-ing a directory fails with EACCES on Windows
                     if e.errno in (errno.ENOENT, errno.EACCES, errno.ENOTDIR,
                                    errno.EISDIR):
                         return False
                     raise
         else:
             def fctxpredfn(f):
                 try:
                     fctx = ctx[f]
                 except error.LookupError:
                     return False
                 return predfn(fctx)
         return self.predicate(fctxpredfn, predrepr=predrepr, cache=cache)
 
     def never(self):
         """Create a matcher to select nothing"""
         repo = self.ctx.repo()
         return matchmod.nevermatcher(repo.root, repo.getcwd(),
                                      badfn=self._badfn)
 
     def switch(self, basectx, ctx):
         return matchctx(basectx, ctx, self._badfn)
 
 # filesets using matchctx.switch()
 _switchcallers = [
     'revs',
     'status',
 ]
 
 def _intree(funcs, tree):
     if isinstance(tree, tuple):
         if tree[0] == 'func' and tree[1][0] == 'symbol':
             if tree[1][1] in funcs:
                 return True
             if tree[1][1] in _switchcallers:
                 # arguments won't be evaluated in the current context
                 return False
         for s in tree[1:]:
             if _intree(funcs, s):
                 return True
     return False
 
 def match(ctx, expr, badfn=None):
     """Create a matcher for a single fileset expression"""
     tree = filesetlang.parse(expr)
     tree = filesetlang.analyze(tree)
     tree = filesetlang.optimize(tree)
     mctx = matchctx(ctx.p1(), ctx, badfn=badfn)
     mctx.buildstatus(tree)
     return getmatch(mctx, tree)
 
 
 def loadpredicate(ui, extname, registrarobj):
     """Load fileset predicates from specified registrarobj
     """
     for name, func in registrarobj._table.iteritems():
         symbols[name] = func
         if func._callstatus:
             _statuscallers.add(name)
 
 # load built-in predicates explicitly to setup _statuscallers
 loadpredicate(None, None, predicate)
 
 # tell hggettext to extract docstrings from these functions:
 i18nfunctions = symbols.values()

mercurial/filesetlang.py

@@ -1,249 +1,330 b''
 # filesetlang.py - parser, tokenizer and utility for file set language
 #
 # Copyright 2010 Matt Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 from __future__ import absolute_import
 
 from .i18n import _
 from . import (
     error,
     parser,
     pycompat,
 )
 
 # common weight constants for static optimization
 # (see registrar.filesetpredicate for details)
 WEIGHT_CHECK_FILENAME = 0.5
 WEIGHT_READ_CONTENTS = 30
 WEIGHT_STATUS = 10
 WEIGHT_STATUS_THOROUGH = 50
 
 elements = {
     # token-type: binding-strength, primary, prefix, infix, suffix
     "(": (20, None, ("group", 1, ")"), ("func", 1, ")"), None),
     ":": (15, None, None, ("kindpat", 15), None),
     "-": (5, None, ("negate", 19), ("minus", 5), None),
     "not": (10, None, ("not", 10), None, None),
     "!": (10, None, ("not", 10), None, None),
     "and": (5, None, None, ("and", 5), None),
     "&": (5, None, None, ("and", 5), None),
     "or": (4, None, None, ("or", 4), None),
     "|": (4, None, None, ("or", 4), None),
     "+": (4, None, None, ("or", 4), None),
     ",": (2, None, None, ("list", 2), None),
     ")": (0, None, None, None, None),
     "symbol": (0, "symbol", None, None, None),
     "string": (0, "string", None, None, None),
     "end": (0, None, None, None, None),
 }
 
 keywords = {'and', 'or', 'not'}
 
 symbols = {}
 
 globchars = ".*{}[]?/\\_"
 
 def tokenize(program):
     pos, l = 0, len(program)
     program = pycompat.bytestr(program)
     while pos < l:
         c = program[pos]
         if c.isspace(): # skip inter-token whitespace
             pass
         elif c in "(),-:|&+!": # handle simple operators
             yield (c, None, pos)
         elif (c in '"\'' or c == 'r' and
               program[pos:pos + 2] in ("r'", 'r"')): # handle quoted strings
             if c == 'r':
                 pos += 1
                 c = program[pos]
                 decode = lambda x: x
             else:
                 decode = parser.unescapestr
             pos += 1
             s = pos
             while pos < l: # find closing quote
                 d = program[pos]
                 if d == '\\': # skip over escaped characters
                     pos += 2
                     continue
                 if d == c:
                     yield ('string', decode(program[s:pos]), s)
                     break
                 pos += 1
             else:
                 raise error.ParseError(_("unterminated string"), s)
         elif c.isalnum() or c in globchars or ord(c) > 127:
             # gather up a symbol/keyword
             s = pos
             pos += 1
             while pos < l: # find end of symbol
                 d = program[pos]
                 if not (d.isalnum() or d in globchars or ord(d) > 127):
                     break
                 pos += 1
             sym = program[s:pos]
             if sym in keywords: # operator keywords
                 yield (sym, None, s)
             else:
                 yield ('symbol', sym, s)
             pos -= 1
         else:
             raise error.ParseError(_("syntax error"), pos)
         pos += 1
     yield ('end', None, pos)
 
 def parse(expr):
     p = parser.parser(elements)
     tree, pos = p.parse(tokenize(expr))
     if pos != len(expr):
         raise error.ParseError(_("invalid token"), pos)
     return parser.simplifyinfixops(tree, {'list', 'or'})
 
 def getsymbol(x):
     if x and x[0] == 'symbol':
         return x[1]
     raise error.ParseError(_('not a symbol'))
 
 def getstring(x, err):
     if x and (x[0] == 'string' or x[0] == 'symbol'):
         return x[1]
     raise error.ParseError(err)
 
 def getkindpat(x, y, allkinds, err):
     kind = getsymbol(x)
     pat = getstring(y, err)
     if kind not in allkinds:
         raise error.ParseError(_("invalid pattern kind: %s") % kind)
     return '%s:%s' % (kind, pat)
 
 def getpattern(x, allkinds, err):
     if x and x[0] == 'kindpat':
         return getkindpat(x[1], x[2], allkinds, err)
     return getstring(x, err)
 
 def getlist(x):
     if not x:
         return []
     if x[0] == 'list':
         return list(x[1:])
     return [x]
 
 def getargs(x, min, max, err):
     l = getlist(x)
     if len(l) < min or len(l) > max:
         raise error.ParseError(err)
     return l
 
 def _analyze(x):
     if x is None:
         return x
 
     op = x[0]
     if op in {'string', 'symbol'}:
         return x
     if op == 'kindpat':
         getsymbol(x[1])  # kind must be a symbol
         t = _analyze(x[2])
         return (op, x[1], t)
     if op == 'group':
         return _analyze(x[1])
     if op == 'negate':
         raise error.ParseError(_("can't use negate operator in this context"))
     if op == 'not':
         t = _analyze(x[1])
         return (op, t)
     if op == 'and':
         ta = _analyze(x[1])
         tb = _analyze(x[2])
         return (op, ta, tb)
     if op == 'minus':
         return _analyze(('and', x[1], ('not', x[2])))
     if op in {'list', 'or'}:
         ts = tuple(_analyze(y) for y in x[1:])
         return (op,) + ts
     if op == 'func':
         getsymbol(x[1])  # function name must be a symbol
         ta = _analyze(x[2])
         return (op, x[1], ta)
     raise error.ProgrammingError('invalid operator %r' % op)
 
+def _insertstatushints(x):
+    """Insert hint nodes where status should be calculated (first path)
+
+    This works in bottom-up way, summing up status names and inserting hint
+    nodes at 'and' and 'or' as needed. Thus redundant hint nodes may be left.
+
+    Returns (status-names, new-tree) at the given subtree, where status-names
+    is a sum of status names referenced in the given subtree.
+    """
+    if x is None:
+        return (), x
+
+    op = x[0]
+    if op in {'string', 'symbol', 'kindpat'}:
+        return (), x
+    if op == 'not':
+        h, t = _insertstatushints(x[1])
+        return h, (op, t)
+    if op == 'and':
+        ha, ta = _insertstatushints(x[1])
+        hb, tb = _insertstatushints(x[2])
+        hr = ha + hb
+        if ha and hb:
+            return hr, ('withstatus', (op, ta, tb), ('string', ' '.join(hr)))
+        return hr, (op, ta, tb)
+    if op == 'or':
+        hs, ts = zip(*(_insertstatushints(y) for y in x[1:]))
+        hr = sum(hs, ())
+        if sum(bool(h) for h in hs) > 1:
+            return hr, ('withstatus', (op,) + ts, ('string', ' '.join(hr)))
+        return hr, (op,) + ts
+    if op == 'list':
+        hs, ts = zip(*(_insertstatushints(y) for y in x[1:]))
+        return sum(hs, ()), (op,) + ts
+    if op == 'func':
+        f = getsymbol(x[1])
+        # don't propagate 'ha' crossing a function boundary
+        ha, ta = _insertstatushints(x[2])
+        if getattr(symbols.get(f), '_callstatus', False):
+            return (f,), ('withstatus', (op, x[1], ta), ('string', f))
+        return (), (op, x[1], ta)
+    raise error.ProgrammingError('invalid operator %r' % op)
+
+def _mergestatushints(x, instatus):
+    """Remove redundant status hint nodes (second path)
+
+    This is the top-down path to eliminate inner hint nodes.
+    """
+    if x is None:
+        return x
+
+    op = x[0]
+    if op == 'withstatus':
+        if instatus:
+            # drop redundant hint node
+            return _mergestatushints(x[1], instatus)
+        t = _mergestatushints(x[1], instatus=True)
+        return (op, t, x[2])
+    if op in {'string', 'symbol', 'kindpat'}:
+        return x
+    if op == 'not':
+        t = _mergestatushints(x[1], instatus)
+        return (op, t)
+    if op == 'and':
+        ta = _mergestatushints(x[1], instatus)
+        tb = _mergestatushints(x[2], instatus)
+        return (op, ta, tb)
+    if op in {'list', 'or'}:
+        ts = tuple(_mergestatushints(y, instatus) for y in x[1:])
+        return (op,) + ts
+    if op == 'func':
+        # don't propagate 'instatus' crossing a function boundary
+        ta = _mergestatushints(x[2], instatus=False)
+        return (op, x[1], ta)
+    raise error.ProgrammingError('invalid operator %r' % op)
+
 def analyze(x):
     """Transform raw parsed tree to evaluatable tree which can be fed to
     optimize() or getmatch()
 
     All pseudo operations should be mapped to real operations or functions
     defined in methods or symbols table respectively.
     """
-    return _analyze(x)
+    t = _analyze(x)
+    _h, t = _insertstatushints(t)
+    return _mergestatushints(t, instatus=False)
 
 def _optimizeandops(op, ta, tb):
     if tb is not None and tb[0] == 'not':
         return ('minus', ta, tb[1])
     return (op, ta, tb)
 
 def _optimizeunion(xs):
     # collect string patterns so they can be compiled into a single regexp
     ws, ts, ss = [], [], []
     for x in xs:
         w, t = _optimize(x)
         if t is not None and t[0] in {'string', 'symbol', 'kindpat'}:
             ss.append(t)
             continue
         ws.append(w)
         ts.append(t)
     if ss:
         ws.append(WEIGHT_CHECK_FILENAME)
         ts.append(('patterns',) + tuple(ss))
     return ws, ts
 
 def _optimize(x):
     if x is None:
         return 0, x
 
     op = x[0]
+    if op == 'withstatus':
+        w, t = _optimize(x[1])
+        return w, (op, t, x[2])
     if op in {'string', 'symbol'}:
         return WEIGHT_CHECK_FILENAME, x
     if op == 'kindpat':
         w, t = _optimize(x[2])
         return w, (op, x[1], t)
     if op == 'not':
         w, t = _optimize(x[1])
         return w, (op, t)
     if op == 'and':
         wa, ta = _optimize(x[1])
         wb, tb = _optimize(x[2])
         if wa <= wb:
             return wa, _optimizeandops(op, ta, tb)
         else:
             return wb, _optimizeandops(op, tb, ta)
     if op == 'or':
         ws, ts = _optimizeunion(x[1:])
         if len(ts) == 1:
             return ws[0], ts[0] # 'or' operation is fully optimized out
         ts = tuple(it[1] for it in sorted(enumerate(ts),
                                           key=lambda it: ws[it[0]]))
         return max(ws), (op,) + ts
     if op == 'list':
         ws, ts = zip(*(_optimize(y) for y in x[1:]))
         return sum(ws), (op,) + ts
     if op == 'func':
         f = getsymbol(x[1])
         w = getattr(symbols.get(f), '_weight', 1)
         wa, ta = _optimize(x[2])
         return w + wa, (op, x[1], ta)
     raise error.ProgrammingError('invalid operator %r' % op)
 
 def optimize(x):
     """Reorder/rewrite evaluatable tree for optimization
 
     All pseudo operations should be transformed beforehand.
     """
     _w, t = _optimize(x)
     return t
 
 def prettyformat(tree):
     return parser.prettyformat(tree, ('string', 'symbol'))

mercurial/minifileset.py

@@ -1,90 +1,92 b''
 # minifileset.py - a simple language to select files
 #
 # Copyright 2017 Facebook, Inc.
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 from __future__ import absolute_import
 
 from .i18n import _
 from . import (
     error,
     fileset,
     filesetlang,
     pycompat,
 )
 
 def _sizep(x):
     # i18n: "size" is a keyword
     expr = filesetlang.getstring(x, _("size requires an expression"))
     return fileset.sizematcher(expr)
 
 def _compile(tree):
     if not tree:
         raise error.ParseError(_("missing argument"))
     op = tree[0]
-    if op in {'symbol', 'string', 'kindpat'}:
+    if op == 'withstatus':
+        return _compile(tree[1])
+    elif op in {'symbol', 'string', 'kindpat'}:
         name = filesetlang.getpattern(tree, {'path'}, _('invalid file pattern'))
         if name.startswith('**'): # file extension test, ex. "**.tar.gz"
             ext = name[2:]
             for c in pycompat.bytestr(ext):
                 if c in '*{}[]?/\\':
                     raise error.ParseError(_('reserved character: %s') % c)
             return lambda n, s: n.endswith(ext)
         elif name.startswith('path:'): # directory or full path test
             p = name[5:] # prefix
             pl = len(p)
             f = lambda n, s: n.startswith(p) and (len(n) == pl
                                                   or n[pl:pl + 1] == '/')
             return f
         raise error.ParseError(_("unsupported file pattern: %s") % name,
                                hint=_('paths must be prefixed with "path:"'))
     elif op in {'or', 'patterns'}:
         funcs = [_compile(x) for x in tree[1:]]
         return lambda n, s: any(f(n, s) for f in funcs)
     elif op == 'and':
         func1 = _compile(tree[1])
         func2 = _compile(tree[2])
         return lambda n, s: func1(n, s) and func2(n, s)
     elif op == 'not':
         return lambda n, s: not _compile(tree[1])(n, s)
     elif op == 'func':
         symbols = {
             'all': lambda n, s: True,
             'none': lambda n, s: False,
             'size': lambda n, s: _sizep(tree[2])(s),
         }
 
         name = filesetlang.getsymbol(tree[1])
         if name in symbols:
             return symbols[name]
 
         raise error.UnknownIdentifier(name, symbols.keys())
     elif op == 'minus':     # equivalent to 'x and not y'
         func1 = _compile(tree[1])
         func2 = _compile(tree[2])
         return lambda n, s: func1(n, s) and not func2(n, s)
     elif op == 'list':
         raise error.ParseError(_("can't use a list in this context"),
                                hint=_('see \'hg help "filesets.x or y"\''))
     raise error.ProgrammingError('illegal tree: %r' % (tree,))
 
 def compile(text):
     """generate a function (path, size) -> bool from filter specification.
 
     "text" could contain the operators defined by the fileset language for
     common logic operations, and parenthesis for grouping.  The supported path
     tests are '**.extname' for file extension test, and '"path:dir/subdir"'
     for prefix test.  The ``size()`` predicate is borrowed from filesets to test
     file size.  The predicates ``all()`` and ``none()`` are also supported.
 
     '(**.php & size(">10MB")) | **.zip | (path:bin & !path:bin/README)' for
     example, will catch all php files whose size is greater than 10 MB, all
     files whose name ends with ".zip", and all files under "bin" in the repo
     root except for "bin/README".
     """
     tree = filesetlang.parse(text)
     tree = filesetlang.analyze(tree)
     tree = filesetlang.optimize(tree)
     return _compile(tree)

tests/test-fileset.t

@@ -1,883 +1,1037 b''
   $ fileset() {
   >   hg debugfileset --all-files "$@"
   > }
 
   $ hg init repo
   $ cd repo
   $ echo a > a1
   $ echo a > a2
   $ echo b > b1
   $ echo b > b2
   $ hg ci -Am addfiles
   adding a1
   adding a2
   adding b1
   adding b2
 
 Test operators and basic patterns
 
   $ fileset -v a1
   (symbol 'a1')
   * matcher:
   <patternmatcher patterns='(?:a1$)'>
   a1
   $ fileset -v 'a*'
   (symbol 'a*')
   * matcher:
   <patternmatcher patterns='(?:a[^/]*$)'>
   a1
   a2
   $ fileset -v '"re:a\d"'
   (string 're:a\\d')
   * matcher:
   <patternmatcher patterns='(?:a\\d)'>
   a1
   a2
   $ fileset -v '!re:"a\d"'
   (not
     (kindpat
       (symbol 're')
       (string 'a\\d')))
   * matcher:
   <predicatenmatcher
     pred=<not
       <patternmatcher patterns='(?:a\\d)'>>>
   b1
   b2
   $ fileset -v 'path:a1 or glob:b?'
   (or
     (kindpat
       (symbol 'path')
       (symbol 'a1'))
     (kindpat
       (symbol 'glob')
       (symbol 'b?')))
   * matcher:
   <patternmatcher patterns='(?:a1(?:/|$)|b.$)'>
   a1
   b1
   b2
   $ fileset -v --no-show-matcher 'a1 or a2'
   (or
     (symbol 'a1')
     (symbol 'a2'))
   a1
   a2
   $ fileset 'a1 | a2'
   a1
   a2
   $ fileset 'a* and "*1"'
   a1
   $ fileset 'a* & "*1"'
   a1
   $ fileset 'not (r"a*")'
   b1
   b2
   $ fileset '! ("a*")'
   b1
   b2
   $ fileset 'a* - a1'
   a2
   $ fileset 'a_b'
   $ fileset '"\xy"'
   hg: parse error: invalid \x escape* (glob)
   [255]
 
 Test invalid syntax
 
   $ fileset -v '"added"()'
   (func
     (string 'added')
     None)
   hg: parse error: not a symbol
   [255]
   $ fileset -v '()()'
   (func
     (group
       None)
     None)
   hg: parse error: not a symbol
   [255]
   $ fileset -v -- '-x'
   (negate
     (symbol 'x'))
   hg: parse error: can't use negate operator in this context
   [255]
   $ fileset -v -- '-()'
   (negate
     (group
       None))
   hg: parse error: can't use negate operator in this context
   [255]
   $ fileset -p parsed 'a, b, c'
   * parsed:
   (list
     (symbol 'a')
     (symbol 'b')
     (symbol 'c'))
   hg: parse error: can't use a list in this context
   (see 'hg help "filesets.x or y"')
   [255]
 
   $ fileset '"path":.'
   hg: parse error: not a symbol
   [255]
   $ fileset 'path:foo bar'
   hg: parse error at 9: invalid token
   [255]
   $ fileset 'foo:bar:baz'
   hg: parse error: not a symbol
   [255]
   $ fileset 'foo:bar()'
   hg: parse error: pattern must be a string
   [255]
   $ fileset 'foo:bar'
   hg: parse error: invalid pattern kind: foo
   [255]
 
 Show parsed tree at stages:
 
   $ fileset -p unknown a
   abort: invalid stage name: unknown
   [255]
 
   $ fileset -p parsed 'path:a1 or glob:b?'
   * parsed:
   (or
     (kindpat
       (symbol 'path')
       (symbol 'a1'))
     (kindpat
       (symbol 'glob')
       (symbol 'b?')))
   a1
   b1
   b2
 
   $ fileset -p all -s 'a1 or a2 or (grep("b") & clean())'
   * parsed:
   (or
     (symbol 'a1')
     (symbol 'a2')
     (group
       (and
         (func
           (symbol 'grep')
           (string 'b'))
         (func
           (symbol 'clean')
           None))))
   * analyzed:
   (or
     (symbol 'a1')
     (symbol 'a2')
     (and
       (func
         (symbol 'grep')
         (string 'b'))
-      (func
-        (symbol 'clean')
-        None)))
+      (withstatus
+        (func
+          (symbol 'clean')
+          None)
+        (string 'clean'))))
   * optimized:
   (or
     (patterns
       (symbol 'a1')
       (symbol 'a2'))
     (and
-      (func
-        (symbol 'clean')
-        None)
+      (withstatus
+        (func
+          (symbol 'clean')
+          None)
+        (string 'clean'))
       (func
         (symbol 'grep')
         (string 'b'))))
   * matcher:
   <unionmatcher matchers=[
     <patternmatcher patterns='(?:a1$|a2$)'>,
     <intersectionmatcher
       m1=<predicatenmatcher pred=clean>,
       m2=<predicatenmatcher pred=grep('b')>>]>
   a1
   a2
   b1
   b2
 
 Union of basic patterns:
 
   $ fileset -p optimized -s -r. 'a1 or a2 or path:b1'
   * optimized:
   (patterns
     (symbol 'a1')
     (symbol 'a2')
     (kindpat
       (symbol 'path')
       (symbol 'b1')))
   * matcher:
   <patternmatcher patterns='(?:a1$|a2$|b1(?:/|$))'>
   a1
   a2
   b1
 
 OR expression should be reordered by weight:
 
   $ fileset -p optimized -s -r. 'grep("a") or a1 or grep("b") or b2'
   * optimized:
   (or
     (patterns
       (symbol 'a1')
       (symbol 'b2'))
     (func
       (symbol 'grep')
       (string 'a'))
     (func
       (symbol 'grep')
       (string 'b')))
   * matcher:
   <unionmatcher matchers=[
     <patternmatcher patterns='(?:a1$|b2$)'>,
     <predicatenmatcher pred=grep('a')>,
     <predicatenmatcher pred=grep('b')>]>
   a1
   a2
   b1
   b2
 
 Use differencematcher for 'x and not y':
 
   $ fileset -p optimized -s 'a* and not a1'
   * optimized:
   (minus
     (symbol 'a*')
     (symbol 'a1'))
   * matcher:
   <differencematcher
     m1=<patternmatcher patterns='(?:a[^/]*$)'>,
     m2=<patternmatcher patterns='(?:a1$)'>>
   a2
 
   $ fileset -p optimized -s '!binary() and a*'
   * optimized:
   (minus
     (symbol 'a*')
     (func
       (symbol 'binary')
       None))
   * matcher:
   <differencematcher
     m1=<patternmatcher patterns='(?:a[^/]*$)'>,
     m2=<predicatenmatcher pred=binary>>
   a1
   a2
 
 'x - y' is rewritten to 'x and not y' first so the operands can be reordered:
 
   $ fileset -p analyzed -p optimized -s 'a* - a1'
   * analyzed:
   (and
     (symbol 'a*')
     (not
       (symbol 'a1')))
   * optimized:
   (minus
     (symbol 'a*')
     (symbol 'a1'))
   * matcher:
   <differencematcher
     m1=<patternmatcher patterns='(?:a[^/]*$)'>,
     m2=<patternmatcher patterns='(?:a1$)'>>
   a2
 
   $ fileset -p analyzed -p optimized -s 'binary() - a*'
   * analyzed:
   (and
     (func
       (symbol 'binary')
       None)
     (not
       (symbol 'a*')))
   * optimized:
   (and
     (not
       (symbol 'a*'))
     (func
       (symbol 'binary')
       None))
   * matcher:
   <intersectionmatcher
     m1=<predicatenmatcher
       pred=<not
         <patternmatcher patterns='(?:a[^/]*$)'>>>,
     m2=<predicatenmatcher pred=binary>>
 
 Test files status
 
   $ rm a1
   $ hg rm a2
   $ echo b >> b2
   $ hg cp b1 c1
   $ echo c > c2
   $ echo c > c3
   $ cat > .hgignore <<EOF
   > \.hgignore
   > 2$
   > EOF
   $ fileset 'modified()'
   b2
   $ fileset 'added()'
   c1
   $ fileset 'removed()'
   a2
   $ fileset 'deleted()'
   a1
   $ fileset 'missing()'
   a1
   $ fileset 'unknown()'
   c3
   $ fileset 'ignored()'
   .hgignore
   c2
   $ fileset 'hgignore()'
   .hgignore
   a2
   b2
   c2
   $ fileset 'clean()'
   b1
   $ fileset 'copied()'
   c1
 
 Test files status in different revisions
 
   $ hg status -m
   M b2
   $ fileset -r0 'revs("wdir()", modified())' --traceback
   b2
   $ hg status -a
   A c1
   $ fileset -r0 'revs("wdir()", added())'
   c1
   $ hg status --change 0 -a
   A a1
   A a2
   A b1
   A b2
   $ hg status -mru
   M b2
   R a2
   ? c3
   $ fileset -r0 'added() and revs("wdir()", modified() or removed() or unknown())'
   a2
   b2
   $ fileset -r0 'added() or revs("wdir()", added())'
   a1
   a2
   b1
   b2
   c1
 
+Test insertion of status hints
+
+  $ fileset -p optimized 'added()'
+  * optimized:
+  (withstatus
+    (func
+      (symbol 'added')
+      None)
+    (string 'added'))
+  c1
+
+  $ fileset -p optimized 'a* & removed()'
+  * optimized:
+  (and
+    (symbol 'a*')
+    (withstatus
+      (func
+        (symbol 'removed')
+        None)
+      (string 'removed')))
+  a2
+
+  $ fileset -p optimized 'a* - removed()'
+  * optimized:
+  (minus
+    (symbol 'a*')
+    (withstatus
+      (func
+        (symbol 'removed')
+        None)
+      (string 'removed')))
+  a1
+
+  $ fileset -p analyzed -p optimized '(added() + removed()) - a*'
+  * analyzed:
+  (and
+    (withstatus
+      (or
+        (func
+          (symbol 'added')
+          None)
+        (func
+          (symbol 'removed')
+          None))
+      (string 'added removed'))
+    (not
+      (symbol 'a*')))
+  * optimized:
+  (and
+    (not
+      (symbol 'a*'))
+    (withstatus
+      (or
+        (func
+          (symbol 'added')
+          None)
+        (func
+          (symbol 'removed')
+          None))
+      (string 'added removed')))
+  c1
+
+  $ fileset -p optimized 'a* + b* + added() + unknown()'
+  * optimized:
+  (withstatus
+    (or
+      (patterns
+        (symbol 'a*')
+        (symbol 'b*'))
+      (func
+        (symbol 'added')
+        None)
+      (func
+        (symbol 'unknown')
+        None))
+    (string 'added unknown'))
+  a1
+  a2
+  b1
+  b2
+  c1
+  c3
+
+  $ fileset -p analyzed -p optimized 'removed() & missing() & a*'
+  * analyzed:
+  (and
+    (withstatus
+      (and
+        (func
+          (symbol 'removed')
+          None)
+        (func
+          (symbol 'missing')
+          None))
+      (string 'removed missing'))
+    (symbol 'a*'))
+  * optimized:
+  (and
+    (symbol 'a*')
+    (withstatus
+      (and
+        (func
+          (symbol 'removed')
+          None)
+        (func
+          (symbol 'missing')
+          None))
+      (string 'removed missing')))
+
+  $ fileset -p optimized 'clean() & revs(0, added())'
+  * optimized:
+  (and
+    (withstatus
+      (func
+        (symbol 'clean')
+        None)
+      (string 'clean'))
+    (func
+      (symbol 'revs')
+      (list
+        (symbol '0')
+        (withstatus
+          (func
+            (symbol 'added')
+            None)
+          (string 'added')))))
+  b1
+
+  $ fileset -p optimized 'clean() & status(null, 0, b* & added())'
+  * optimized:
+  (and
+    (withstatus
+      (func
+        (symbol 'clean')
+        None)
+      (string 'clean'))
+    (func
+      (symbol 'status')
+      (list
+        (symbol 'null')
+        (symbol '0')
+        (and
+          (symbol 'b*')
+          (withstatus
+            (func
+              (symbol 'added')
+              None)
+            (string 'added'))))))
+  b1
+
 Test files properties
 
   >>> open('bin', 'wb').write(b'\0a') and None
   $ fileset 'binary()'
   bin
   $ fileset 'binary() and unknown()'
   bin
   $ echo '^bin$' >> .hgignore
   $ fileset 'binary() and ignored()'
   bin
   $ hg add bin
   $ fileset 'binary()'
   bin
 
   $ fileset -p optimized -s 'binary() and b*'
   * optimized:
   (and
     (symbol 'b*')
     (func
       (symbol 'binary')
       None))
   * matcher:
   <intersectionmatcher
     m1=<patternmatcher patterns='(?:b[^/]*$)'>,
     m2=<predicatenmatcher pred=binary>>
   bin
 
   $ fileset 'grep("b{1}")'
   .hgignore
   b1
   b2
   c1
   $ fileset 'grep("missingparens(")'
   hg: parse error: invalid match pattern: (unbalanced parenthesis|missing \)).* (re)
   [255]
 
 #if execbit
   $ chmod +x b2
   $ fileset 'exec()'
   b2
 #endif
 
 #if symlink
   $ ln -s b2 b2link
   $ fileset 'symlink() and unknown()'
   b2link
   $ hg add b2link
 #endif
 
 #if no-windows
   $ echo foo > con.xml
   $ fileset 'not portable()'
   con.xml
   $ hg --config ui.portablefilenames=ignore add con.xml
 #endif
 
   >>> open('1k', 'wb').write(b' '*1024) and None
   >>> open('2k', 'wb').write(b' '*2048) and None
   $ hg add 1k 2k
   $ fileset 'size("bar")'
   hg: parse error: couldn't parse size: bar
   [255]
   $ fileset '(1k, 2k)'
   hg: parse error: can't use a list in this context
   (see 'hg help "filesets.x or y"')
   [255]
   $ fileset 'size(1k)'
   1k
   $ fileset '(1k or 2k) and size("< 2k")'
   1k
   $ fileset '(1k or 2k) and size("<=2k")'
   1k
   2k
   $ fileset '(1k or 2k) and size("> 1k")'
   2k
   $ fileset '(1k or 2k) and size(">=1K")'
   1k
   2k
   $ fileset '(1k or 2k) and size(".5KB - 1.5kB")'
   1k
   $ fileset 'size("1M")'
   $ fileset 'size("1 GB")'
 
 Test merge states
 
   $ hg ci -m manychanges
   $ hg file -r . 'set:copied() & modified()'
   [1]
   $ hg up -C 0
   * files updated, 0 files merged, * files removed, 0 files unresolved (glob)
   $ echo c >> b2
   $ hg ci -m diverging b2
   created new head
   $ fileset 'resolved()'
   $ fileset 'unresolved()'
   $ hg merge
   merging b2
   warning: conflicts while merging b2! (edit, then use 'hg resolve --mark')
   * files updated, 0 files merged, 1 files removed, 1 files unresolved (glob)
   use 'hg resolve' to retry unresolved file merges or 'hg merge --abort' to abandon
   [1]
   $ fileset 'resolved()'
   $ fileset 'unresolved()'
   b2
   $ echo e > b2
   $ hg resolve -m b2
   (no more unresolved files)
   $ fileset 'resolved()'
   b2
   $ fileset 'unresolved()'
   $ hg ci -m merge
 
 Test subrepo predicate
 
   $ hg init sub
   $ echo a > sub/suba
   $ hg -R sub add sub/suba
   $ hg -R sub ci -m sub
   $ echo 'sub = sub' > .hgsub
   $ hg init sub2
   $ echo b > sub2/b
   $ hg -R sub2 ci -Am sub2
   adding b
   $ echo 'sub2 = sub2' >> .hgsub
   $ fileset 'subrepo()'
   $ hg add .hgsub
   $ fileset 'subrepo()'
   sub
   sub2
   $ fileset 'subrepo("sub")'
   sub
   $ fileset 'subrepo("glob:*")'
   sub
   sub2
   $ hg ci -m subrepo
 
 Test that .hgsubstate is updated as appropriate during a conversion.  The
 saverev property is enough to alter the hashes of the subrepo.
 
   $ hg init ../converted
   $ hg --config extensions.convert= convert --config convert.hg.saverev=True  \
   >      sub ../converted/sub
   initializing destination ../converted/sub repository
   scanning source...
   sorting...
   converting...
   0 sub
   $ hg clone -U sub2 ../converted/sub2
   $ hg --config extensions.convert= convert --config convert.hg.saverev=True  \
   >      . ../converted
   scanning source...
   sorting...
   converting...
   4 addfiles
   3 manychanges
   2 diverging
   1 merge
   0 subrepo
   no ".hgsubstate" updates will be made for "sub2"
   $ hg up -q -R ../converted -r tip
   $ hg --cwd ../converted cat sub/suba sub2/b -r tip
   a
   b
   $ oldnode=`hg log -r tip -T "{node}\n"`
   $ newnode=`hg log -R ../converted -r tip -T "{node}\n"`
   $ [ "$oldnode" != "$newnode" ] || echo "nothing changed"
 
 Test with a revision
 
   $ hg log -G --template '{rev} {desc}\n'
   @  4 subrepo
   |
   o    3 merge
   |\
   | o  2 diverging
   | |
   o |  1 manychanges
   |/
   o  0 addfiles
   
   $ echo unknown > unknown
   $ fileset -r1 'modified()'
   b2
   $ fileset -r1 'added() and c1'
   c1
   $ fileset -r1 'removed()'
   a2
   $ fileset -r1 'deleted()'
   $ fileset -r1 'unknown()'
   $ fileset -r1 'ignored()'
   $ fileset -r1 'hgignore()'
   .hgignore
   a2
   b2
   bin
   c2
   sub2
   $ fileset -r1 'binary()'
   bin
   $ fileset -r1 'size(1k)'
   1k
   $ fileset -r3 'resolved()'
   $ fileset -r3 'unresolved()'
 
 #if execbit
   $ fileset -r1 'exec()'
   b2
 #endif
 
 #if symlink
   $ fileset -r1 'symlink()'
   b2link
 #endif
 
 #if no-windows
   $ fileset -r1 'not portable()'
   con.xml
   $ hg forget 'con.xml'
 #endif
 
   $ fileset -r4 'subrepo("re:su.*")'
   sub
   sub2
   $ fileset -r4 'subrepo(re:su.*)'
   sub
   sub2
   $ fileset -r4 'subrepo("sub")'
   sub
   $ fileset -r4 'b2 or c1'
   b2
   c1
 
   >>> open('dos', 'wb').write(b"dos\r\n") and None
   >>> open('mixed', 'wb').write(b"dos\r\nunix\n") and None
   >>> open('mac', 'wb').write(b"mac\r") and None
   $ hg add dos mixed mac
 
 (remove a1, to examine safety of 'eol' on removed files)
   $ rm a1
 
   $ fileset 'eol(dos)'
   dos
   mixed
   $ fileset 'eol(unix)'
   .hgignore
   .hgsub
   .hgsubstate
   b1
   b2
   b2.orig
   c1
   c2
   c3
   con.xml (no-windows !)
   mixed
   unknown
   $ fileset 'eol(mac)'
   mac
 
 Test safety of 'encoding' on removed files
 
   $ fileset 'encoding("ascii")'
   .hgignore
   .hgsub
   .hgsubstate
   1k
   2k
   b1
   b2
   b2.orig
   b2link (symlink !)
   bin
   c1
   c2
   c3
   con.xml (no-windows !)
   dos
   mac
   mixed
   unknown
 
 Test 'revs(...)'
 ================
 
 small reminder of the repository state
 
   $ hg log -G
   @  changeset:   4:* (glob)
   |  tag:         tip
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     subrepo
   |
   o    changeset:   3:* (glob)
   |\   parent:      2:55b05bdebf36
   | |  parent:      1:* (glob)
   | |  user:        test
   | |  date:        Thu Jan 01 00:00:00 1970 +0000
   | |  summary:     merge
   | |
   | o  changeset:   2:55b05bdebf36
   | |  parent:      0:8a9576c51c1f
   | |  user:        test
   | |  date:        Thu Jan 01 00:00:00 1970 +0000
   | |  summary:     diverging
   | |
   o |  changeset:   1:* (glob)
   |/   user:        test
   |    date:        Thu Jan 01 00:00:00 1970 +0000
   |    summary:     manychanges
   |
   o  changeset:   0:8a9576c51c1f
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     addfiles
   
   $ hg status --change 0
   A a1
   A a2
   A b1
   A b2
   $ hg status --change 1
   M b2
   A 1k
   A 2k
   A b2link (no-windows !)
   A bin
   A c1
   A con.xml (no-windows !)
   R a2
   $ hg status --change 2
   M b2
   $ hg status --change 3
   M b2
   A 1k
   A 2k
   A b2link (no-windows !)
   A bin
   A c1
   A con.xml (no-windows !)
   R a2
   $ hg status --change 4
   A .hgsub
   A .hgsubstate
   $ hg status
   A dos
   A mac
   A mixed
   R con.xml (no-windows !)
   ! a1
   ? b2.orig
   ? c3
   ? unknown
 
 Test files at -r0 should be filtered by files at wdir
 -----------------------------------------------------
 
   $ fileset -r0 'tracked() and revs("wdir()", tracked())'
   a1
   b1
   b2
 
 Test that "revs()" work at all
 ------------------------------
 
   $ fileset "revs('2', modified())"
   b2
 
 Test that "revs()" work for file missing in the working copy/current context
 ----------------------------------------------------------------------------
 
 (a2 not in working copy)
 
   $ fileset "revs('0', added())"
   a1
   a2
   b1
   b2
 
 (none of the file exist in "0")
 
   $ fileset -r 0 "revs('4', added())"
   .hgsub
   .hgsubstate
 
 Call with empty revset
 --------------------------
 
   $ fileset "revs('2-2', modified())"
 
 Call with revset matching multiple revs
 ---------------------------------------
 
   $ fileset "revs('0+4', added())"
   .hgsub
   .hgsubstate
   a1
   a2
   b1
   b2
 
 overlapping set
 
   $ fileset "revs('1+2', modified())"
   b2
 
 test 'status(...)'
 =================
 
 Simple case
 -----------
 
   $ fileset "status(3, 4, added())"
   .hgsub
   .hgsubstate
 
 use rev to restrict matched file
 -----------------------------------------
 
   $ hg status --removed --rev 0 --rev 1
   R a2
   $ fileset "status(0, 1, removed())"
   a2
   $ fileset "tracked() and status(0, 1, removed())"
   $ fileset -r 4 "status(0, 1, removed())"
   a2
   $ fileset -r 4 "tracked() and status(0, 1, removed())"
   $ fileset "revs('4', tracked() and status(0, 1, removed()))"
   $ fileset "revs('0', tracked() and status(0, 1, removed()))"
   a2
 
 check wdir()
 ------------
 
   $ hg status --removed  --rev 4
   R con.xml (no-windows !)
   $ fileset "status(4, 'wdir()', removed())"
   con.xml (no-windows !)
 
   $ hg status --removed --rev 2
   R a2
   $ fileset "status('2', 'wdir()', removed())"
   a2
 
 test backward status
 --------------------
 
   $ hg status --removed --rev 0 --rev 4
   R a2
   $ hg status --added --rev 4 --rev 0
   A a2
   $ fileset "status(4, 0, added())"
   a2
 
 test cross branch status
 ------------------------
 
   $ hg status --added --rev 1 --rev 2
   A a2
   $ fileset "status(1, 2, added())"
   a2
 
 test with multi revs revset
 ---------------------------
   $ hg status --added --rev 0:1 --rev 3:4
   A .hgsub
   A .hgsubstate
   A 1k
   A 2k
   A b2link (no-windows !)
   A bin
   A c1
   A con.xml (no-windows !)
   $ fileset "status('0:1', '3:4', added())"
   .hgsub
   .hgsubstate
   1k
   2k
   b2link (no-windows !)
   bin
   c1
   con.xml (no-windows !)
 
 tests with empty value
 ----------------------
 
 Fully empty revset
 
   $ fileset "status('', '4', added())"
   hg: parse error: first argument to status must be a revision
   [255]
   $ fileset "status('2', '', added())"
   hg: parse error: second argument to status must be a revision
   [255]
 
 Empty revset will error at the revset layer
 
   $ fileset "status(' ', '4', added())"
   hg: parse error at 1: not a prefix: end
   ( 
     ^ here)
   [255]
   $ fileset "status('2', ' ', added())"
   hg: parse error at 1: not a prefix: end
   ( 
     ^ here)
   [255]