comparison mercurial/revsetlang.py @ 41221:73203cdfe3fe

revset: detect integer list on parsing

Right now, using "%ld" with `repo.revs("…%ld…", somerevs)` is very
inefficient, all items in `somerevs` will be serialized to ascii and then
reparsed as integers. If `somerevs` contains just an handful of entry this is
fine, however, when you get to thousands or hundreds of thousands of revisions
this becomes very slow.

To avoid this serialization we need to first detect this situation. The code
involved in the whole process is quite complex so we start simple and focus on
some "simple" but widespread cases.

So far we only detect the situation and don't do anything special about it.
The singled out will be serialized in `formatspec` in the same way as before.

41220:8d26026b3335

from . import (
    error,
    node,
    parser,
    pycompat,
    util,
)
from .utils import (
    stringutil,
)

    parsed = _parseargs(expr, args)
    ret = []
    for t, arg in parsed:
        if t is None:
            ret.append(arg)
        else:
            raise error.ProgrammingError("unknown revspec item type: %r" % t)
    return b''.join(ret)

def _parseargs(expr, args):
    """parse the expression and replace all inexpensive args

    return a list of tuple [(arg-type, arg-value)]

    Arg-type can be:
    * None: a string ready to be concatenated into a final spec
    """
    expr = pycompat.bytestr(expr)
    argiter = iter(args)
    ret = []
    pos = 0

            raise error.ParseError(_('missing argument for revspec'))
        f = _formatlistfuncs.get(d)
        if f:
            # a list of some type, might be expensive, do not replace
            pos += 1
            try:
                d = expr[pos]
            except IndexError:
                raise error.ParseError(_('incomplete revspec format character'))
            try:
                ret.append((None, f(list(arg), d)))
            except (TypeError, ValueError):
                raise error.ParseError(_('invalid argument for revspec'))
        else:

41221:73203cdfe3fe

from . import (
    error,
    node,
    parser,
    pycompat,
    smartset,
    util,
)
from .utils import (
    stringutil,
)

    parsed = _parseargs(expr, args)
    ret = []
    for t, arg in parsed:
        if t is None:
            ret.append(arg)
        elif t == 'baseset':
            if isinstance(arg, set):
                arg = sorted(arg)
            ret.append(_formatintlist(list(arg)))
        else:
            raise error.ProgrammingError("unknown revspec item type: %r" % t)
    return b''.join(ret)

def _parseargs(expr, args):
    """parse the expression and replace all inexpensive args

    return a list of tuple [(arg-type, arg-value)]

    Arg-type can be:
    * None:      a string ready to be concatenated into a final spec
    * 'baseset': an iterable of revisions
    """
    expr = pycompat.bytestr(expr)
    argiter = iter(args)
    ret = []
    pos = 0

            raise error.ParseError(_('missing argument for revspec'))
        f = _formatlistfuncs.get(d)
        if f:
            # a list of some type, might be expensive, do not replace
            pos += 1
            islist = (d == 'l')
            try:
                d = expr[pos]
            except IndexError:
                raise error.ParseError(_('incomplete revspec format character'))
            if islist and d == 'd' and arg:
                # special case, we might be able to speedup the list of int case
                #
                # We have been very conservative here for the first version.
                # Other types (eg: generator) are probably fine, but we did not
                # wanted to take any risk>
                safeinputtype = (list, tuple, set, smartset.abstractsmartset)
                if isinstance(arg, safeinputtype):
                    # we don't create a baseset yet, because it come with an
                    # extra cost. If we are going to serialize it we better
                    # skip it.
                    ret.append(('baseset', arg))
                    pos += 1
                    continue
            try:
                ret.append((None, f(list(arg), d)))
            except (TypeError, ValueError):
                raise error.ParseError(_('invalid argument for revspec'))
        else: