( )⚙ D657 revset: move weight information to predicate

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D657

revset: move weight information to predicate
ClosedPublic

Authored by quark on Sep 7 2017, 12:16 PM.

Details

Reviewers
phillco
krbullock
singhsrb
yuja
Group Reviewers
hg-reviewers
Commits
rHGb0790bebfcf8: revset: move weight information to predicate
Summary

Previously revset weight is hardcoded and cannot be modified. This patch
moves it to predicate so newly registered revsets could define their weight
to properly give static optimization some hint.

Diff Detail

Repository
rHG Mercurial
Lint
Lint Skipped
Unit
Unit Tests Skipped

Event Timeline

quark created this revision.Sep 7 2017, 12:16 PM
phillco accepted this revision.Sep 7 2017, 1:37 PM
phillco added a subscriber: phillco.

lgtm

mercurial/revset.py
256

I take it this dictionary was moved there because of the import direction?

quark added inline comments.Sep 7 2017, 6:15 PM
mercurial/revset.py
256

Yes.

yuja added a subscriber: yuja.Sep 8 2017, 10:08 AM

Perhaps we'll need to make these magic numbers less obfuscated. Before, weights
were defined in one location and functions were grouped, so it wasn't hard to guess
what sort of functions should belonged to e.g. the w=30 group. With this patch,
weights can be arbitrary chosen by extension authors, but could we choose the
right value?

quark added a comment.Sep 8 2017, 2:11 PM

How about trying to document it? ex.

'weight' is an estimated number for static optimization so things like "given
'x & y', calculate x first or y first?" could be decided. 'weight' has a
default value 10. revset with O(changelog.d) complexity usually have weight
100, revset which also needs reading manifest diffs usually have weight 30,
revset reading file contents usually have weight 100. For a similar time
complexity, revset returning less revisions could have less weight.
phillco added a comment.Sep 8 2017, 2:24 PM

Constants could pobably help make it more self-documenting.

krbullock requested changes to this revision.Sep 18 2017, 4:13 PM
krbullock added a subscriber: krbullock.

I think either expanding the docs or using constants would be fine, but the default weight looks like it's 1, not 10.

This revision now requires changes to proceed.Sep 18 2017, 4:13 PM
quark added a comment.Sep 18 2017, 7:39 PM

I think it's hard to use constants since that would implicitly limit the possibilities. Time complexity choices are unbounded in theory. So I'll go the documentation approach.

quark updated this revision to Diff 1882.Sep 18 2017, 7:47 PM
quark updated this revision to Diff 1883.
singhsrb accepted this revision.Sep 18 2017, 8:54 PM
yuja requested changes to this revision.Sep 19 2017, 11:04 AM

(copied from the email thread, though I'm okay with the latest patch.)

On Fri, 8 Sep 2017 18:24:44 +0000, phillco (Phil Cohen) wrote:

phillco added a comment.

Constants could pobably help make it more self-documenting.

Perhaps. And maybe we can add a debug command that shows a list of revset
functions sorted by weight.

mercurial/registrar.py
175

contains() does not read file contents, but manifest contents.

This revision now requires changes to proceed.Sep 19 2017, 11:04 AM
quark updated this revision to Diff 1895.Sep 19 2017, 1:31 PM
quark updated this revision to Diff 1896.Sep 19 2017, 1:45 PM
yuja accepted this revision.Sep 20 2017, 8:35 AM

Queued, thanks.

Closed by commit rHGb0790bebfcf8: revset: move weight information to predicate (authored by quark). · Explain WhySep 20 2017, 9:02 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mmercurial/registrar.py (7 lines)
Mmercurial/revset.py (47 lines)
Mmercurial/revsetlang.py (18 lines)

Diff 1666

mercurial/registrar.py

The first string argument is used also in online help. The first string argument is used also in online help.
Optional argument 'safe' indicates whether a predicate is safe for Optional argument 'safe' indicates whether a predicate is safe for
DoS attack (False by default). DoS attack (False by default).
Optional argument 'takeorder' indicates whether a predicate function Optional argument 'takeorder' indicates whether a predicate function
takes ordering policy as the last argument. takes ordering policy as the last argument.
Optional argument 'weight' indicates the estimated run-time cost, useful
for static optimization. Higher weight means more expensive. For example,
'contains' has a weight of 100.
'revsetpredicate' instance in example above can be used to 'revsetpredicate' instance in example above can be used to
decorate multiple functions. decorate multiple functions.
yujaUnsubmitted
Not Done

contains() does not read file contents, but manifest contents.

yuja: contains() does not read file contents, but manifest contents.
Decorated functions are registered automatically at loading Decorated functions are registered automatically at loading
extension, if an instance named as 'revsetpredicate' is used for extension, if an instance named as 'revsetpredicate' is used for
decorating in extension. decorating in extension.
Otherwise, explicit 'revset.loadpredicate()' is needed. Otherwise, explicit 'revset.loadpredicate()' is needed.
""" """
_getname = _funcregistrarbase._parsefuncdecl _getname = _funcregistrarbase._parsefuncdecl
_docformat = "``%s``\n %s" _docformat = "``%s``\n %s"
def _extrasetup(self, name, func, safe=False, takeorder=False): def _extrasetup(self, name, func, safe=False, takeorder=False, weight=1):
func._safe = safe func._safe = safe
func._takeorder = takeorder func._takeorder = takeorder
func._weight = weight
class filesetpredicate(_funcregistrarbase): class filesetpredicate(_funcregistrarbase):
"""Decorator to register fileset predicate """Decorator to register fileset predicate
Usage:: Usage::
filesetpredicate = registrar.filesetpredicate() filesetpredicate = registrar.filesetpredicate()

mercurial/revset.py

# functions # functions
# symbols are callables like: # symbols are callables like:
# fn(repo, subset, x) # fn(repo, subset, x)
# with: # with:
# repo - current repository instance # repo - current repository instance
# subset - of revisions to be examined # subset - of revisions to be examined
# x - argument in tree form # x - argument in tree form
symbols = {} symbols = revsetlang.symbols
phillcoUnsubmitted
Not Done

I take it this dictionary was moved there because of the import direction?

phillco: I take it this dictionary was moved there because of the import direction?
quarkAuthorUnsubmitted
Not Done

Yes.

quark: Yes.
# symbols which can't be used for a DoS attack for any given input # symbols which can't be used for a DoS attack for any given input
# (e.g. those which accept regexes as plain strings shouldn't be included) # (e.g. those which accept regexes as plain strings shouldn't be included)
# functions that just return a lot of changesets (like all) don't count here # functions that just return a lot of changesets (like all) don't count here
safesymbols = set() safesymbols = set()
predicate = registrar.revsetpredicate() predicate = registrar.revsetpredicate()
@predicate('_destupdate') @predicate('_destupdate')
def _destupdate(repo, subset, x): def _destupdate(repo, subset, x):
# experimental revset for update destination # experimental revset for update destination
args = getargsdict(x, 'limit', 'clean') args = getargsdict(x, 'limit', 'clean')
return subset & baseset([destutil.destupdate(repo, **args)[0]]) return subset & baseset([destutil.destupdate(repo, **args)[0]])
@predicate('_destmerge') @predicate('_destmerge')
def _destmerge(repo, subset, x): def _destmerge(repo, subset, x):
# experimental revset for merge destination # experimental revset for merge destination
sourceset = None sourceset = None
if x is not None: if x is not None:
sourceset = getset(repo, fullreposet(repo), x) sourceset = getset(repo, fullreposet(repo), x)
return subset & baseset([destutil.destmerge(repo, sourceset=sourceset)]) return subset & baseset([destutil.destmerge(repo, sourceset=sourceset)])
@predicate('adds(pattern)', safe=True) @predicate('adds(pattern)', safe=True, weight=30)
def adds(repo, subset, x): def adds(repo, subset, x):
"""Changesets that add a file matching pattern. """Changesets that add a file matching pattern.
The pattern without explicit kind like ``glob:`` is expected to be The pattern without explicit kind like ``glob:`` is expected to be
relative to the current directory and match against a file or a relative to the current directory and match against a file or a
directory. directory.
""" """
# i18n: "adds" is a keyword # i18n: "adds" is a keyword
pat = getstring(x, _("adds requires a pattern")) pat = getstring(x, _("adds requires a pattern"))
return checkstatus(repo, subset, pat, 1) return checkstatus(repo, subset, pat, 1)
@predicate('ancestor(*changeset)', safe=True) @predicate('ancestor(*changeset)', safe=True, weight=0.5)
def ancestor(repo, subset, x): def ancestor(repo, subset, x):
"""A greatest common ancestor of the changesets. """A greatest common ancestor of the changesets.
Accepts 0 or more changesets. Accepts 0 or more changesets.
Will return empty list when passed no args. Will return empty list when passed no args.
Greatest common ancestor of a single changeset is that changeset. Greatest common ancestor of a single changeset is that changeset.
""" """
# i18n: "ancestor" is a keyword # i18n: "ancestor" is a keyword
for i in range(n): for i in range(n):
try: try:
r = cl.parentrevs(r)[0] r = cl.parentrevs(r)[0]
except error.WdirUnsupported: except error.WdirUnsupported:
r = repo[r].parents()[0].rev() r = repo[r].parents()[0].rev()
ps.add(r) ps.add(r)
return subset & ps return subset & ps
@predicate('author(string)', safe=True) @predicate('author(string)', safe=True, weight=10)
def author(repo, subset, x): def author(repo, subset, x):
"""Alias for ``user(string)``. """Alias for ``user(string)``.
""" """
# i18n: "author" is a keyword # i18n: "author" is a keyword
n = getstring(x, _("author requires a string")) n = getstring(x, _("author requires a string"))
kind, pattern, matcher = _substringmatcher(n, casesensitive=False) kind, pattern, matcher = _substringmatcher(n, casesensitive=False)
return subset.filter(lambda x: matcher(repo[x].user()), return subset.filter(lambda x: matcher(repo[x].user()),
condrepr=('<user %r>', n)) condrepr=('<user %r>', n))
" that match '%s'") % pattern) " that match '%s'") % pattern)
for bmrev in matchrevs: for bmrev in matchrevs:
bms.add(repo[bmrev].rev()) bms.add(repo[bmrev].rev())
else: else:
bms = {repo[r].rev() for r in repo._bookmarks.values()} bms = {repo[r].rev() for r in repo._bookmarks.values()}
bms -= {node.nullrev} bms -= {node.nullrev}
return subset & bms return subset & bms
@predicate('branch(string or set)', safe=True) @predicate('branch(string or set)', safe=True, weight=10)
def branch(repo, subset, x): def branch(repo, subset, x):
""" """
All changesets belonging to the given branch or the branches of the given All changesets belonging to the given branch or the branches of the given
changesets. changesets.
Pattern matching is supported for `string`. See Pattern matching is supported for `string`. See
:hg:`help revisions.patterns`. :hg:`help revisions.patterns`.
""" """
@predicate('children(set)', safe=True) @predicate('children(set)', safe=True)
def children(repo, subset, x): def children(repo, subset, x):
"""Child changesets of changesets in set. """Child changesets of changesets in set.
""" """
s = getset(repo, fullreposet(repo), x) s = getset(repo, fullreposet(repo), x)
cs = _children(repo, subset, s) cs = _children(repo, subset, s)
return subset & cs return subset & cs
@predicate('closed()', safe=True) @predicate('closed()', safe=True, weight=10)
def closed(repo, subset, x): def closed(repo, subset, x):
"""Changeset is closed. """Changeset is closed.
""" """
# i18n: "closed" is a keyword # i18n: "closed" is a keyword
getargs(x, 0, 0, _("closed takes no arguments")) getargs(x, 0, 0, _("closed takes no arguments"))
return subset.filter(lambda r: repo[r].closesbranch(), return subset.filter(lambda r: repo[r].closesbranch(),
condrepr='<branch closed>') condrepr='<branch closed>')
@predicate('contains(pattern)') @predicate('contains(pattern)', weight=100)
def contains(repo, subset, x): def contains(repo, subset, x):
"""The revision's manifest contains a file matching pattern (but might not """The revision's manifest contains a file matching pattern (but might not
modify it). See :hg:`help patterns` for information about file patterns. modify it). See :hg:`help patterns` for information about file patterns.
The pattern without explicit kind like ``glob:`` is expected to be The pattern without explicit kind like ``glob:`` is expected to be
relative to the current directory and match against a file exactly relative to the current directory and match against a file exactly
for efficiency. for efficiency.
""" """
def _matchvalue(r): def _matchvalue(r):
source = repo[r].extra().get('convert_revision', None) source = repo[r].extra().get('convert_revision', None)
return source is not None and (rev is None or source.startswith(rev)) return source is not None and (rev is None or source.startswith(rev))
return subset.filter(lambda r: _matchvalue(r), return subset.filter(lambda r: _matchvalue(r),
condrepr=('<converted %r>', rev)) condrepr=('<converted %r>', rev))
@predicate('date(interval)', safe=True) @predicate('date(interval)', safe=True, weight=10)
def date(repo, subset, x): def date(repo, subset, x):
"""Changesets within the interval, see :hg:`help dates`. """Changesets within the interval, see :hg:`help dates`.
""" """
# i18n: "date" is a keyword # i18n: "date" is a keyword
ds = getstring(x, _("date requires a string")) ds = getstring(x, _("date requires a string"))
dm = util.matchdate(ds) dm = util.matchdate(ds)
return subset.filter(lambda x: dm(repo[x].date()[0]), return subset.filter(lambda x: dm(repo[x].date()[0]),
condrepr=('<date %r>', ds)) condrepr=('<date %r>', ds))
@predicate('desc(string)', safe=True) @predicate('desc(string)', safe=True, weight=10)
def desc(repo, subset, x): def desc(repo, subset, x):
"""Search commit message for string. The match is case-insensitive. """Search commit message for string. The match is case-insensitive.
Pattern matching is supported for `string`. See Pattern matching is supported for `string`. See
:hg:`help revisions.patterns`. :hg:`help revisions.patterns`.
""" """
# i18n: "desc" is a keyword # i18n: "desc" is a keyword
ds = getstring(x, _("desc requires a string")) ds = getstring(x, _("desc requires a string"))
startdepth=startdepth, stopdepth=stopdepth) startdepth=startdepth, stopdepth=stopdepth)
@predicate('_firstdescendants', safe=True) @predicate('_firstdescendants', safe=True)
def _firstdescendants(repo, subset, x): def _firstdescendants(repo, subset, x):
# ``_firstdescendants(set)`` # ``_firstdescendants(set)``
# Like ``descendants(set)`` but follows only the first parents. # Like ``descendants(set)`` but follows only the first parents.
return _descendants(repo, subset, x, followfirst=True) return _descendants(repo, subset, x, followfirst=True)
@predicate('destination([set])', safe=True) @predicate('destination([set])', safe=True, weight=10)
def destination(repo, subset, x): def destination(repo, subset, x):
"""Changesets that were created by a graft, transplant or rebase operation, """Changesets that were created by a graft, transplant or rebase operation,
with the given revisions specified as the source. Omitting the optional set with the given revisions specified as the source. Omitting the optional set
is the same as passing all(). is the same as passing all().
""" """
if x is not None: if x is not None:
sources = getset(repo, fullreposet(repo), x) sources = getset(repo, fullreposet(repo), x)
else: else:
else: else:
known[n] = r known[n] = r
except error.ManifestLookupError: except error.ManifestLookupError:
# deletion in changelog # deletion in changelog
continue continue
return subset & s return subset & s
@predicate('first(set, [n])', safe=True, takeorder=True) @predicate('first(set, [n])', safe=True, takeorder=True, weight=0)
def first(repo, subset, x, order): def first(repo, subset, x, order):
"""An alias for limit(). """An alias for limit().
""" """
return limit(repo, subset, x, order) return limit(repo, subset, x, order)
def _follow(repo, subset, x, name, followfirst=False): def _follow(repo, subset, x, name, followfirst=False):
l = getargs(x, 0, 2, _("%s takes no arguments or a pattern " l = getargs(x, 0, 2, _("%s takes no arguments or a pattern "
"and an optional revset") % name) "and an optional revset") % name)
@predicate('all()', safe=True) @predicate('all()', safe=True)
def getall(repo, subset, x): def getall(repo, subset, x):
"""All changesets, the same as ``0:tip``. """All changesets, the same as ``0:tip``.
""" """
# i18n: "all" is a keyword # i18n: "all" is a keyword
getargs(x, 0, 0, _("all takes no arguments")) getargs(x, 0, 0, _("all takes no arguments"))
return subset & spanset(repo) # drop "null" if any return subset & spanset(repo) # drop "null" if any
@predicate('grep(regex)') @predicate('grep(regex)', weight=10)
def grep(repo, subset, x): def grep(repo, subset, x):
"""Like ``keyword(string)`` but accepts a regex. Use ``grep(r'...')`` """Like ``keyword(string)`` but accepts a regex. Use ``grep(r'...')``
to ensure special escape characters are handled correctly. Unlike to ensure special escape characters are handled correctly. Unlike
``keyword(string)``, the match is case-sensitive. ``keyword(string)``, the match is case-sensitive.
""" """
try: try:
# i18n: "grep" is a keyword # i18n: "grep" is a keyword
gr = re.compile(getstring(x, _("grep requires a string"))) gr = re.compile(getstring(x, _("grep requires a string")))
return True return True
return False return False
return subset.filter(matches, return subset.filter(matches,
condrepr=('<matchfiles patterns=%r, include=%r ' condrepr=('<matchfiles patterns=%r, include=%r '
'exclude=%r, default=%r, rev=%r>', 'exclude=%r, default=%r, rev=%r>',
pats, inc, exc, default, rev)) pats, inc, exc, default, rev))
@predicate('file(pattern)', safe=True) @predicate('file(pattern)', safe=True, weight=10)
def hasfile(repo, subset, x): def hasfile(repo, subset, x):
"""Changesets affecting files matched by pattern. """Changesets affecting files matched by pattern.
For a faster but less accurate result, consider using ``filelog()`` For a faster but less accurate result, consider using ``filelog()``
instead. instead.
This predicate uses ``glob:`` as the default kind of pattern. This predicate uses ``glob:`` as the default kind of pattern.
""" """
def hidden(repo, subset, x): def hidden(repo, subset, x):
"""Hidden changesets. """Hidden changesets.
""" """
# i18n: "hidden" is a keyword # i18n: "hidden" is a keyword
getargs(x, 0, 0, _("hidden takes no arguments")) getargs(x, 0, 0, _("hidden takes no arguments"))
hiddenrevs = repoview.filterrevs(repo, 'visible') hiddenrevs = repoview.filterrevs(repo, 'visible')
return subset & hiddenrevs return subset & hiddenrevs
@predicate('keyword(string)', safe=True) @predicate('keyword(string)', safe=True, weight=10)
def keyword(repo, subset, x): def keyword(repo, subset, x):
"""Search commit message, user name, and names of changed files for """Search commit message, user name, and names of changed files for
string. The match is case-insensitive. string. The match is case-insensitive.
For a regular expression or case sensitive search of these fields, use For a regular expression or case sensitive search of these fields, use
``grep(regex)``. ``grep(regex)``.
""" """
# i18n: "keyword" is a keyword # i18n: "keyword" is a keyword
kw = encoding.lower(getstring(x, _("keyword requires a string"))) kw = encoding.lower(getstring(x, _("keyword requires a string")))
def matches(r): def matches(r):
c = repo[r] c = repo[r]
return any(kw in encoding.lower(t) return any(kw in encoding.lower(t)
for t in c.files() + [c.user(), c.description()]) for t in c.files() + [c.user(), c.description()])
return subset.filter(matches, condrepr=('<keyword %r>', kw)) return subset.filter(matches, condrepr=('<keyword %r>', kw))
@predicate('limit(set[, n[, offset]])', safe=True, takeorder=True) @predicate('limit(set[, n[, offset]])', safe=True, takeorder=True, weight=0)
def limit(repo, subset, x, order): def limit(repo, subset, x, order):
"""First n members of set, defaulting to 1, starting from offset. """First n members of set, defaulting to 1, starting from offset.
""" """
args = getargsdict(x, 'limit', 'set n offset') args = getargsdict(x, 'limit', 'set n offset')
if 'set' not in args: if 'set' not in args:
# i18n: "limit" is a keyword # i18n: "limit" is a keyword
raise error.ParseError(_("limit requires one to three arguments")) raise error.ParseError(_("limit requires one to three arguments"))
# i18n: "limit" is a keyword # i18n: "limit" is a keyword
if m in subset: if m in subset:
return baseset([m], datarepr=('<min %r, %r>', subset, os)) return baseset([m], datarepr=('<min %r, %r>', subset, os))
except ValueError: except ValueError:
# os.min() throws a ValueError when the collection is empty. # os.min() throws a ValueError when the collection is empty.
# Same as python's min(). # Same as python's min().
pass pass
return baseset(datarepr=('<min %r, %r>', subset, os)) return baseset(datarepr=('<min %r, %r>', subset, os))
@predicate('modifies(pattern)', safe=True) @predicate('modifies(pattern)', safe=True, weight=30)
def modifies(repo, subset, x): def modifies(repo, subset, x):
"""Changesets modifying files matched by pattern. """Changesets modifying files matched by pattern.
The pattern without explicit kind like ``glob:`` is expected to be The pattern without explicit kind like ``glob:`` is expected to be
relative to the current directory and match against a file or a relative to the current directory and match against a file or a
directory. directory.
""" """
# i18n: "modifies" is a keyword # i18n: "modifies" is a keyword
src = prev src = prev
o = {_firstsrc(r) for r in dests} o = {_firstsrc(r) for r in dests}
o -= {None} o -= {None}
# XXX we should turn this into a baseset instead of a set, smartset may do # XXX we should turn this into a baseset instead of a set, smartset may do
# some optimizations from the fact this is a baseset. # some optimizations from the fact this is a baseset.
return subset & o return subset & o
@predicate('outgoing([path])', safe=False) @predicate('outgoing([path])', safe=False, weight=10)
def outgoing(repo, subset, x): def outgoing(repo, subset, x):
"""Changesets not found in the specified destination repository, or the """Changesets not found in the specified destination repository, or the
default push location. default push location.
""" """
# Avoid cycles. # Avoid cycles.
from . import ( from . import (
discovery, discovery,
hg, hg,
other = hg.peer(repo, {}, dest) other = hg.peer(repo, {}, dest)
n = other.lookup(q) n = other.lookup(q)
if n in repo: if n in repo:
r = repo[n].rev() r = repo[n].rev()
if r in subset: if r in subset:
return baseset([r]) return baseset([r])
return baseset() return baseset()
@predicate('removes(pattern)', safe=True) @predicate('removes(pattern)', safe=True, weight=30)
def removes(repo, subset, x): def removes(repo, subset, x):
"""Changesets which remove files matching pattern. """Changesets which remove files matching pattern.
The pattern without explicit kind like ``glob:`` is expected to be The pattern without explicit kind like ``glob:`` is expected to be
relative to the current directory and match against a file or a relative to the current directory and match against a file or a
directory. directory.
""" """
# i18n: "removes" is a keyword # i18n: "removes" is a keyword
if target[n] != f(x): if target[n] != f(x):
match = False match = False
if match: if match:
return True return True
return False return False
return subset.filter(matches, condrepr=('<matching%r %r>', fields, revs)) return subset.filter(matches, condrepr=('<matching%r %r>', fields, revs))
@predicate('reverse(set)', safe=True, takeorder=True) @predicate('reverse(set)', safe=True, takeorder=True, weight=0)
def reverse(repo, subset, x, order): def reverse(repo, subset, x, order):
"""Reverse order of set. """Reverse order of set.
""" """
l = getset(repo, subset, x, order) l = getset(repo, subset, x, order)
if order == defineorder: if order == defineorder:
l.reverse() l.reverse()
return l return l
opts['topo.firstbranch'] = args['topo.firstbranch'] opts['topo.firstbranch'] = args['topo.firstbranch']
else: else:
# i18n: "topo" and "topo.firstbranch" are keywords # i18n: "topo" and "topo.firstbranch" are keywords
raise error.ParseError(_('topo.firstbranch can only be used ' raise error.ParseError(_('topo.firstbranch can only be used '
'when using the topo sort key')) 'when using the topo sort key'))
return args['set'], keyflags, opts return args['set'], keyflags, opts
@predicate('sort(set[, [-]key... [, ...]])', safe=True, takeorder=True) @predicate('sort(set[, [-]key... [, ...]])', safe=True, takeorder=True,
weight=10)
def sort(repo, subset, x, order): def sort(repo, subset, x, order):
"""Sort set by keys. The default sort order is ascending, specify a key """Sort set by keys. The default sort order is ascending, specify a key
as ``-key`` to sort in descending order. as ``-key`` to sort in descending order.
The keys can be: The keys can be:
- ``rev`` for the revision number, - ``rev`` for the revision number,
- ``branch`` for the branch name, - ``branch`` for the branch name,
"""Non-obsolete changesets with obsolete ancestors. (EXPERIMENTAL) """Non-obsolete changesets with obsolete ancestors. (EXPERIMENTAL)
""" """
# i18n: "orphan" is a keyword # i18n: "orphan" is a keyword
getargs(x, 0, 0, _("orphan takes no arguments")) getargs(x, 0, 0, _("orphan takes no arguments"))
orphan = obsmod.getrevs(repo, 'orphan') orphan = obsmod.getrevs(repo, 'orphan')
return subset & orphan return subset & orphan
@predicate('user(string)', safe=True) @predicate('user(string)', safe=True, weight=10)
def user(repo, subset, x): def user(repo, subset, x):
"""User name contains string. The match is case-insensitive. """User name contains string. The match is case-insensitive.
Pattern matching is supported for `string`. See Pattern matching is supported for `string`. See
:hg:`help revisions.patterns`. :hg:`help revisions.patterns`.
""" """
return author(repo, subset, x) return author(repo, subset, x)
@predicate('wdir()', safe=True) @predicate('wdir()', safe=True, weight=0)
def wdir(repo, subset, x): def wdir(repo, subset, x):
"""Working directory. (EXPERIMENTAL)""" """Working directory. (EXPERIMENTAL)"""
# i18n: "wdir" is a keyword # i18n: "wdir" is a keyword
getargs(x, 0, 0, _("wdir takes no arguments")) getargs(x, 0, 0, _("wdir takes no arguments"))
if node.wdirrev in subset or isinstance(subset, fullreposet): if node.wdirrev in subset or isinstance(subset, fullreposet):
return baseset([node.wdirrev]) return baseset([node.wdirrev])
return baseset() return baseset()
s = getstring(x, "internal error") s = getstring(x, "internal error")
if not s: if not s:
return baseset() return baseset()
ls = [int(r) for r in s.split('\0')] ls = [int(r) for r in s.split('\0')]
s = subset s = subset
return baseset([r for r in ls if r in s]) return baseset([r for r in ls if r in s])
# for internal use # for internal use
@predicate('_intlist', safe=True, takeorder=True) @predicate('_intlist', safe=True, takeorder=True, weight=0)
def _intlist(repo, subset, x, order): def _intlist(repo, subset, x, order):
if order == followorder: if order == followorder:
# slow path to take the subset order # slow path to take the subset order
return subset & _orderedintlist(repo, fullreposet(repo), x) return subset & _orderedintlist(repo, fullreposet(repo), x)
else: else:
return _orderedintlist(repo, subset, x) return _orderedintlist(repo, subset, x)
def _orderedhexlist(repo, subset, x): def _orderedhexlist(repo, subset, x):

mercurial/revsetlang.py

"]": (0, None, None, None, None), "]": (0, None, None, None, None),
"symbol": (0, "symbol", None, None, None), "symbol": (0, "symbol", None, None, None),
"string": (0, "string", None, None, None), "string": (0, "string", None, None, None),
"end": (0, None, None, None, None), "end": (0, None, None, None, None),
} }
keywords = {'and', 'or', 'not'} keywords = {'and', 'or', 'not'}
symbols = {}
_quoteletters = {'"', "'"} _quoteletters = {'"', "'"}
_simpleopletters = set(pycompat.iterbytestr("()[]#:=,-|&+!~^%")) _simpleopletters = set(pycompat.iterbytestr("()[]#:=,-|&+!~^%"))
# default set of valid characters for the initial letter of symbols # default set of valid characters for the initial letter of symbols
_syminitletters = set(pycompat.iterbytestr( _syminitletters = set(pycompat.iterbytestr(
string.ascii_letters.encode('ascii') + string.ascii_letters.encode('ascii') +
string.digits.encode('ascii') + string.digits.encode('ascii') +
'._@')) | set(map(pycompat.bytechr, xrange(128, 256))) '._@')) | set(map(pycompat.bytechr, xrange(128, 256)))
ws, ts = zip(*(_optimize(y) for y in x[1:])) ws, ts = zip(*(_optimize(y) for y in x[1:]))
return sum(ws), (op,) + ts return sum(ws), (op,) + ts
elif op == 'keyvalue': elif op == 'keyvalue':
w, t = _optimize(x[2]) w, t = _optimize(x[2])
return w, (op, x[1], t) return w, (op, x[1], t)
elif op == 'func': elif op == 'func':
f = getsymbol(x[1]) f = getsymbol(x[1])
wa, ta = _optimize(x[2]) wa, ta = _optimize(x[2])
if f in ('author', 'branch', 'closed', 'date', 'desc', 'file', 'grep', w = getattr(symbols.get(f), '_weight', 1)
'keyword', 'outgoing', 'user', 'destination'):
w = 10 # slow
elif f in ('modifies', 'adds', 'removes'):
w = 30 # slower
elif f == "contains":
w = 100 # very slow
elif f == "ancestor":
w = 0.5
elif f in ('reverse', 'limit', 'first', 'wdir', '_intlist'):
w = 0
elif f == "sort":
w = 10 # assume most sorts look at changelog
else:
w = 1
return w + wa, (op, x[1], ta) return w + wa, (op, x[1], ta)
raise ValueError('invalid operator %r' % op) raise ValueError('invalid operator %r' % op)
def optimize(tree): def optimize(tree):
"""Optimize evaluatable tree """Optimize evaluatable tree
All pseudo operations should be transformed beforehand. All pseudo operations should be transformed beforehand.
""" """