--- a/mercurial/revsetlang.py	Sun Oct 06 09:45:02 2019 -0400
+++ b/mercurial/revsetlang.py	Sun Oct 06 09:48:39 2019 -0400
@@ -22,63 +22,63 @@
 
 elements = {
     # token-type: binding-strength, primary, prefix, infix, suffix
-    "(": (21, None, ("group", 1, ")"), ("func", 1, ")"), None),
-    "[": (21, None, None, ("subscript", 1, "]"), None),
-    "#": (21, None, None, ("relation", 21), None),
-    "##": (20, None, None, ("_concat", 20), None),
-    "~": (18, None, None, ("ancestor", 18), None),
-    "^": (18, None, None, ("parent", 18), "parentpost"),
-    "-": (5, None, ("negate", 19), ("minus", 5), None),
-    "::": (
+    b"(": (21, None, (b"group", 1, b")"), (b"func", 1, b")"), None),
+    b"[": (21, None, None, (b"subscript", 1, b"]"), None),
+    b"#": (21, None, None, (b"relation", 21), None),
+    b"##": (20, None, None, (b"_concat", 20), None),
+    b"~": (18, None, None, (b"ancestor", 18), None),
+    b"^": (18, None, None, (b"parent", 18), b"parentpost"),
+    b"-": (5, None, (b"negate", 19), (b"minus", 5), None),
+    b"::": (
         17,
-        "dagrangeall",
-        ("dagrangepre", 17),
-        ("dagrange", 17),
-        "dagrangepost",
+        b"dagrangeall",
+        (b"dagrangepre", 17),
+        (b"dagrange", 17),
+        b"dagrangepost",
     ),
-    "..": (
+    b"..": (
         17,
-        "dagrangeall",
-        ("dagrangepre", 17),
-        ("dagrange", 17),
-        "dagrangepost",
+        b"dagrangeall",
+        (b"dagrangepre", 17),
+        (b"dagrange", 17),
+        b"dagrangepost",
     ),
-    ":": (15, "rangeall", ("rangepre", 15), ("range", 15), "rangepost"),
-    "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),
-    "%": (5, None, None, ("only", 5), "onlypost"),
-    "or": (4, None, None, ("or", 4), None),
-    "|": (4, None, None, ("or", 4), None),
-    "+": (4, None, None, ("or", 4), None),
-    "=": (3, None, None, ("keyvalue", 3), None),
-    ",": (2, None, None, ("list", 2), None),
-    ")": (0, None, None, None, None),
-    "]": (0, None, None, None, None),
-    "symbol": (0, "symbol", None, None, None),
-    "string": (0, "string", None, None, None),
-    "end": (0, None, None, None, None),
+    b":": (15, b"rangeall", (b"rangepre", 15), (b"range", 15), b"rangepost"),
+    b"not": (10, None, (b"not", 10), None, None),
+    b"!": (10, None, (b"not", 10), None, None),
+    b"and": (5, None, None, (b"and", 5), None),
+    b"&": (5, None, None, (b"and", 5), None),
+    b"%": (5, None, None, (b"only", 5), b"onlypost"),
+    b"or": (4, None, None, (b"or", 4), None),
+    b"|": (4, None, None, (b"or", 4), None),
+    b"+": (4, None, None, (b"or", 4), None),
+    b"=": (3, None, None, (b"keyvalue", 3), None),
+    b",": (2, None, None, (b"list", 2), None),
+    b")": (0, None, None, None, None),
+    b"]": (0, None, None, None, None),
+    b"symbol": (0, b"symbol", None, None, None),
+    b"string": (0, b"string", None, None, None),
+    b"end": (0, None, None, None, None),
 }
 
-keywords = {'and', 'or', 'not'}
+keywords = {b'and', b'or', b'not'}
 
 symbols = {}
 
-_quoteletters = {'"', "'"}
-_simpleopletters = set(pycompat.iterbytestr("()[]#:=,-|&+!~^%"))
+_quoteletters = {b'"', b"'"}
+_simpleopletters = set(pycompat.iterbytestr(b"()[]#:=,-|&+!~^%"))
 
 # default set of valid characters for the initial letter of symbols
 _syminitletters = set(
     pycompat.iterbytestr(
         pycompat.sysbytes(string.ascii_letters)
         + pycompat.sysbytes(string.digits)
-        + '._@'
+        + b'._@'
     )
 ) | set(map(pycompat.bytechr, pycompat.xrange(128, 256)))
 
 # default set of valid characters for non-initial letters of symbols
-_symletters = _syminitletters | set(pycompat.iterbytestr('-/'))
+_symletters = _syminitletters | set(pycompat.iterbytestr(b'-/'))
 
 
 def tokenize(program, lookup=None, syminitletters=None, symletters=None):
@@ -104,7 +104,7 @@
     '''
     if not isinstance(program, bytes):
         raise error.ProgrammingError(
-            'revset statement must be bytes, got %r' % program
+            b'revset statement must be bytes, got %r' % program
         )
     program = pycompat.bytestr(program)
     if syminitletters is None:
@@ -115,16 +115,16 @@
     if program and lookup:
         # attempt to parse old-style ranges first to deal with
         # things like old-tag which contain query metacharacters
-        parts = program.split(':', 1)
+        parts = program.split(b':', 1)
         if all(lookup(sym) for sym in parts if sym):
             if parts[0]:
-                yield ('symbol', parts[0], 0)
+                yield (b'symbol', parts[0], 0)
             if len(parts) > 1:
                 s = len(parts[0])
-                yield (':', None, s)
+                yield (b':', None, s)
                 if parts[1]:
-                    yield ('symbol', parts[1], s + 1)
-            yield ('end', None, len(program))
+                    yield (b'symbol', parts[1], s + 1)
+            yield (b'end', None, len(program))
             return
 
     pos, l = 0, len(program)
@@ -133,28 +133,28 @@
         if c.isspace():  # skip inter-token whitespace
             pass
         elif (
-            c == ':' and program[pos : pos + 2] == '::'
+            c == b':' and program[pos : pos + 2] == b'::'
         ):  # look ahead carefully
-            yield ('::', None, pos)
+            yield (b'::', None, pos)
             pos += 1  # skip ahead
         elif (
-            c == '.' and program[pos : pos + 2] == '..'
+            c == b'.' and program[pos : pos + 2] == b'..'
         ):  # look ahead carefully
-            yield ('..', None, pos)
+            yield (b'..', None, pos)
             pos += 1  # skip ahead
         elif (
-            c == '#' and program[pos : pos + 2] == '##'
+            c == b'#' and program[pos : pos + 2] == b'##'
         ):  # look ahead carefully
-            yield ('##', None, pos)
+            yield (b'##', None, pos)
             pos += 1  # skip ahead
         elif c in _simpleopletters:  # handle simple operators
             yield (c, None, pos)
         elif (
             c in _quoteletters
-            or c == 'r'
-            and program[pos : pos + 2] in ("r'", 'r"')
+            or c == b'r'
+            and program[pos : pos + 2] in (b"r'", b'r"')
         ):  # handle quoted strings
-            if c == 'r':
+            if c == b'r':
                 pos += 1
                 c = program[pos]
                 decode = lambda x: x
@@ -164,15 +164,15 @@
             s = pos
             while pos < l:  # find closing quote
                 d = program[pos]
-                if d == '\\':  # skip over escaped characters
+                if d == b'\\':  # skip over escaped characters
                     pos += 2
                     continue
                 if d == c:
-                    yield ('string', decode(program[s:pos]), s)
+                    yield (b'string', decode(program[s:pos]), s)
                     break
                 pos += 1
             else:
-                raise error.ParseError(_("unterminated string"), s)
+                raise error.ParseError(_(b"unterminated string"), s)
         # gather up a symbol/keyword
         elif c in syminitletters:
             s = pos
@@ -181,38 +181,40 @@
                 d = program[pos]
                 if d not in symletters:
                     break
-                if d == '.' and program[pos - 1] == '.':  # special case for ..
+                if (
+                    d == b'.' and program[pos - 1] == b'.'
+                ):  # special case for ..
                     pos -= 1
                     break
                 pos += 1
             sym = program[s:pos]
             if sym in keywords:  # operator keywords
                 yield (sym, None, s)
-            elif '-' in sym:
+            elif b'-' in sym:
                 # some jerk gave us foo-bar-baz, try to check if it's a symbol
                 if lookup and lookup(sym):
                     # looks like a real symbol
-                    yield ('symbol', sym, s)
+                    yield (b'symbol', sym, s)
                 else:
                     # looks like an expression
-                    parts = sym.split('-')
+                    parts = sym.split(b'-')
                     for p in parts[:-1]:
                         if p:  # possible consecutive -
-                            yield ('symbol', p, s)
+                            yield (b'symbol', p, s)
                         s += len(p)
-                        yield ('-', None, s)
+                        yield (b'-', None, s)
                         s += 1
                     if parts[-1]:  # possible trailing -
-                        yield ('symbol', parts[-1], s)
+                        yield (b'symbol', parts[-1], s)
             else:
-                yield ('symbol', sym, s)
+                yield (b'symbol', sym, s)
             pos -= 1
         else:
             raise error.ParseError(
-                _("syntax error in revset '%s'") % program, pos
+                _(b"syntax error in revset '%s'") % program, pos
             )
         pos += 1
-    yield ('end', None, pos)
+    yield (b'end', None, pos)
 
 
 # helpers
@@ -221,13 +223,13 @@
 
 
 def getsymbol(x):
-    if x and x[0] == 'symbol':
+    if x and x[0] == b'symbol':
         return x[1]
-    raise error.ParseError(_('not a symbol'))
+    raise error.ParseError(_(b'not a symbol'))
 
 
 def getstring(x, err):
-    if x and (x[0] == 'string' or x[0] == 'symbol'):
+    if x and (x[0] == b'string' or x[0] == b'symbol'):
         return x[1]
     raise error.ParseError(err)
 
@@ -251,7 +253,7 @@
 def getlist(x):
     if not x:
         return []
-    if x[0] == 'list':
+    if x[0] == b'list':
         return list(x[1:])
     return [x]
 
@@ -260,13 +262,13 @@
     if not x:
         raise error.ParseError(err)
     op = x[0]
-    if op == 'range':
+    if op == b'range':
         return x[1], x[2]
-    elif op == 'rangepre':
+    elif op == b'rangepre':
         return None, x[1]
-    elif op == 'rangepost':
+    elif op == b'rangepost':
         return x[1], None
-    elif op == 'rangeall':
+    elif op == b'rangeall':
         return None, None
     raise error.ParseError(err)
 
@@ -277,7 +279,7 @@
     If any of the sides omitted, and if no default provided, ParseError will
     be raised.
     """
-    if x and (x[0] == 'string' or x[0] == 'symbol'):
+    if x and (x[0] == b'string' or x[0] == b'symbol'):
         n = getinteger(x, err1)
         return n, n
     a, b = getrange(x, err1)
@@ -296,8 +298,8 @@
         getlist(x),
         funcname,
         parser.splitargspec(keys),
-        keyvaluenode='keyvalue',
-        keynode='symbol',
+        keyvaluenode=b'keyvalue',
+        keynode=b'symbol',
     )
 
 
@@ -320,7 +322,7 @@
     ('and', ('func', ('symbol', 'f'), ('string', '1')), ('symbol', '2'))
     """
     template = _cachedtree(tmplspec)
-    return parser.buildtree(template, ('symbol', '_'), *repls)
+    return parser.buildtree(template, (b'symbol', b'_'), *repls)
 
 
 def _match(patspec, tree):
@@ -333,12 +335,12 @@
     """
     pattern = _cachedtree(patspec)
     return parser.matchtree(
-        pattern, tree, ('symbol', '_'), {'keyvalue', 'list'}
+        pattern, tree, (b'symbol', b'_'), {b'keyvalue', b'list'}
     )
 
 
 def _matchonly(revs, bases):
-    return _match('ancestors(_) and not ancestors(_)', ('and', revs, bases))
+    return _match(b'ancestors(_) and not ancestors(_)', (b'and', revs, bases))
 
 
 def _fixops(x):
@@ -348,25 +350,25 @@
         return x
 
     op = x[0]
-    if op == 'parent':
+    if op == b'parent':
         # x^:y means (x^) : y, not x ^ (:y)
         # x^:  means (x^) :,   not x ^ (:)
-        post = ('parentpost', x[1])
-        if x[2][0] == 'dagrangepre':
-            return _fixops(('dagrange', post, x[2][1]))
-        elif x[2][0] == 'dagrangeall':
-            return _fixops(('dagrangepost', post))
-        elif x[2][0] == 'rangepre':
-            return _fixops(('range', post, x[2][1]))
-        elif x[2][0] == 'rangeall':
-            return _fixops(('rangepost', post))
-    elif op == 'or':
+        post = (b'parentpost', x[1])
+        if x[2][0] == b'dagrangepre':
+            return _fixops((b'dagrange', post, x[2][1]))
+        elif x[2][0] == b'dagrangeall':
+            return _fixops((b'dagrangepost', post))
+        elif x[2][0] == b'rangepre':
+            return _fixops((b'range', post, x[2][1]))
+        elif x[2][0] == b'rangeall':
+            return _fixops((b'rangepost', post))
+    elif op == b'or':
         # make number of arguments deterministic:
         # x + y + z -> (or x y z) -> (or (list x y z))
-        return (op, _fixops(('list',) + x[1:]))
-    elif op == 'subscript' and x[1][0] == 'relation':
+        return (op, _fixops((b'list',) + x[1:]))
+    elif op == b'subscript' and x[1][0] == b'relation':
         # x#y[z] ternary
-        return _fixops(('relsubscript', x[1][1], x[1][2], x[2]))
+        return _fixops((b'relsubscript', x[1][1], x[1][2], x[2]))
 
     return (op,) + tuple(_fixops(y) for y in x[1:])
 
@@ -376,53 +378,53 @@
         return x
 
     op = x[0]
-    if op == 'minus':
-        return _analyze(_build('_ and not _', *x[1:]))
-    elif op == 'only':
-        return _analyze(_build('only(_, _)', *x[1:]))
-    elif op == 'onlypost':
-        return _analyze(_build('only(_)', x[1]))
-    elif op == 'dagrangeall':
-        raise error.ParseError(_("can't use '::' in this context"))
-    elif op == 'dagrangepre':
-        return _analyze(_build('ancestors(_)', x[1]))
-    elif op == 'dagrangepost':
-        return _analyze(_build('descendants(_)', x[1]))
-    elif op == 'negate':
-        s = getstring(x[1], _("can't negate that"))
-        return _analyze(('string', '-' + s))
-    elif op in ('string', 'symbol', 'smartset'):
+    if op == b'minus':
+        return _analyze(_build(b'_ and not _', *x[1:]))
+    elif op == b'only':
+        return _analyze(_build(b'only(_, _)', *x[1:]))
+    elif op == b'onlypost':
+        return _analyze(_build(b'only(_)', x[1]))
+    elif op == b'dagrangeall':
+        raise error.ParseError(_(b"can't use '::' in this context"))
+    elif op == b'dagrangepre':
+        return _analyze(_build(b'ancestors(_)', x[1]))
+    elif op == b'dagrangepost':
+        return _analyze(_build(b'descendants(_)', x[1]))
+    elif op == b'negate':
+        s = getstring(x[1], _(b"can't negate that"))
+        return _analyze((b'string', b'-' + s))
+    elif op in (b'string', b'symbol', b'smartset'):
         return x
-    elif op == 'rangeall':
+    elif op == b'rangeall':
         return (op, None)
-    elif op in {'or', 'not', 'rangepre', 'rangepost', 'parentpost'}:
+    elif op in {b'or', b'not', b'rangepre', b'rangepost', b'parentpost'}:
         return (op, _analyze(x[1]))
-    elif op == 'group':
+    elif op == b'group':
         return _analyze(x[1])
     elif op in {
-        'and',
-        'dagrange',
-        'range',
-        'parent',
-        'ancestor',
-        'relation',
-        'subscript',
+        b'and',
+        b'dagrange',
+        b'range',
+        b'parent',
+        b'ancestor',
+        b'relation',
+        b'subscript',
     }:
         ta = _analyze(x[1])
         tb = _analyze(x[2])
         return (op, ta, tb)
-    elif op == 'relsubscript':
+    elif op == b'relsubscript':
         ta = _analyze(x[1])
         tb = _analyze(x[2])
         tc = _analyze(x[3])
         return (op, ta, tb, tc)
-    elif op == 'list':
+    elif op == b'list':
         return (op,) + tuple(_analyze(y) for y in x[1:])
-    elif op == 'keyvalue':
+    elif op == b'keyvalue':
         return (op, x[1], _analyze(x[2]))
-    elif op == 'func':
+    elif op == b'func':
         return (op, x[1], _analyze(x[2]))
-    raise ValueError('invalid operator %r' % op)
+    raise ValueError(b'invalid operator %r' % op)
 
 
 def analyze(x):
@@ -440,30 +442,30 @@
         return 0, x
 
     op = x[0]
-    if op in ('string', 'symbol', 'smartset'):
+    if op in (b'string', b'symbol', b'smartset'):
         return 0.5, x  # single revisions are small
-    elif op == 'and':
+    elif op == b'and':
         wa, ta = _optimize(x[1])
         wb, tb = _optimize(x[2])
         w = min(wa, wb)
 
         # (draft/secret/_notpublic() & ::x) have a fast path
-        m = _match('_() & ancestors(_)', ('and', ta, tb))
-        if m and getsymbol(m[1]) in {'draft', 'secret', '_notpublic'}:
-            return w, _build('_phaseandancestors(_, _)', m[1], m[2])
+        m = _match(b'_() & ancestors(_)', (b'and', ta, tb))
+        if m and getsymbol(m[1]) in {b'draft', b'secret', b'_notpublic'}:
+            return w, _build(b'_phaseandancestors(_, _)', m[1], m[2])
 
         # (::x and not ::y)/(not ::y and ::x) have a fast path
         m = _matchonly(ta, tb) or _matchonly(tb, ta)
         if m:
-            return w, _build('only(_, _)', *m[1:])
+            return w, _build(b'only(_, _)', *m[1:])
 
-        m = _match('not _', tb)
+        m = _match(b'not _', tb)
         if m:
-            return wa, ('difference', ta, m[1])
+            return wa, (b'difference', ta, m[1])
         if wa > wb:
-            op = 'andsmally'
+            op = b'andsmally'
         return w, (op, ta, tb)
-    elif op == 'or':
+    elif op == b'or':
         # fast path for machine-generated expression, that is likely to have
         # lots of trivial revisions: 'a + b + c()' to '_list(a b) + c()'
         ws, ts, ss = [], [], []
@@ -474,8 +476,8 @@
             if len(ss) == 1:
                 w, t = ss[0]
             else:
-                s = '\0'.join(t[1] for w, t in ss)
-                y = _build('_list(_)', ('string', s))
+                s = b'\0'.join(t[1] for w, t in ss)
+                y = _build(b'_list(_)', (b'string', s))
                 w, t = _optimize(y)
             ws.append(w)
             ts.append(t)
@@ -483,7 +485,7 @@
 
         for y in getlist(x[1]):
             w, t = _optimize(y)
-            if t is not None and (t[0] == 'string' or t[0] == 'symbol'):
+            if t is not None and (t[0] == b'string' or t[0] == b'symbol'):
                 ss.append((w, t))
                 continue
             flushss()
@@ -492,48 +494,48 @@
         flushss()
         if len(ts) == 1:
             return ws[0], ts[0]  # 'or' operation is fully optimized out
-        return max(ws), (op, ('list',) + tuple(ts))
-    elif op == 'not':
+        return max(ws), (op, (b'list',) + tuple(ts))
+    elif op == b'not':
         # Optimize not public() to _notpublic() because we have a fast version
-        if _match('public()', x[1]):
-            o = _optimize(_build('_notpublic()'))
+        if _match(b'public()', x[1]):
+            o = _optimize(_build(b'_notpublic()'))
             return o[0], o[1]
         else:
             o = _optimize(x[1])
             return o[0], (op, o[1])
-    elif op == 'rangeall':
+    elif op == b'rangeall':
         return 1, x
-    elif op in ('rangepre', 'rangepost', 'parentpost'):
+    elif op in (b'rangepre', b'rangepost', b'parentpost'):
         o = _optimize(x[1])
         return o[0], (op, o[1])
-    elif op in ('dagrange', 'range'):
+    elif op in (b'dagrange', b'range'):
         wa, ta = _optimize(x[1])
         wb, tb = _optimize(x[2])
         return wa + wb, (op, ta, tb)
-    elif op in ('parent', 'ancestor', 'relation', 'subscript'):
+    elif op in (b'parent', b'ancestor', b'relation', b'subscript'):
         w, t = _optimize(x[1])
         return w, (op, t, x[2])
-    elif op == 'relsubscript':
+    elif op == b'relsubscript':
         w, t = _optimize(x[1])
         return w, (op, t, x[2], x[3])
-    elif op == 'list':
+    elif op == b'list':
         ws, ts = zip(*(_optimize(y) for y in x[1:]))
         return sum(ws), (op,) + ts
-    elif op == 'keyvalue':
+    elif op == b'keyvalue':
         w, t = _optimize(x[2])
         return w, (op, x[1], t)
-    elif op == 'func':
+    elif op == b'func':
         f = getsymbol(x[1])
         wa, ta = _optimize(x[2])
         w = getattr(symbols.get(f), '_weight', 1)
-        m = _match('commonancestors(_)', ta)
+        m = _match(b'commonancestors(_)', ta)
 
         # Optimize heads(commonancestors(_)) because we have a fast version
-        if f == 'heads' and m:
-            return w + wa, _build('_commonancestorheads(_)', m[1])
+        if f == b'heads' and m:
+            return w + wa, _build(b'_commonancestorheads(_)', m[1])
 
         return w + wa, (op, x[1], ta)
-    raise ValueError('invalid operator %r' % op)
+    raise ValueError(b'invalid operator %r' % op)
 
 
 def optimize(tree):
@@ -547,7 +549,7 @@
 
 # the set of valid characters for the initial letter of symbols in
 # alias declarations and definitions
-_aliassyminitletters = _syminitletters | {'$'}
+_aliassyminitletters = _syminitletters | {b'$'}
 
 
 def _parsewith(spec, lookup=None, syminitletters=None):
@@ -564,21 +566,21 @@
       ...
     ParseError: ('invalid token', 4)
     """
-    if lookup and spec.startswith('revset(') and spec.endswith(')'):
+    if lookup and spec.startswith(b'revset(') and spec.endswith(b')'):
         lookup = None
     p = parser.parser(elements)
     tree, pos = p.parse(
         tokenize(spec, lookup=lookup, syminitletters=syminitletters)
     )
     if pos != len(spec):
-        raise error.ParseError(_('invalid token'), pos)
-    return _fixops(parser.simplifyinfixops(tree, ('list', 'or')))
+        raise error.ParseError(_(b'invalid token'), pos)
+    return _fixops(parser.simplifyinfixops(tree, (b'list', b'or')))
 
 
 class _aliasrules(parser.basealiasrules):
     """Parsing and expansion rule set of revset aliases"""
 
-    _section = _('revset alias')
+    _section = _(b'revset alias')
 
     @staticmethod
     def _parse(spec):
@@ -592,7 +594,7 @@
 
     @staticmethod
     def _trygetfunc(tree):
-        if tree[0] == 'func' and tree[1][0] == 'symbol':
+        if tree[0] == b'func' and tree[1][0] == b'symbol':
             return tree[1][1], getlist(tree[2])
 
 
@@ -604,7 +606,7 @@
     if warn is not None:
         for name, alias in sorted(aliases.iteritems()):
             if alias.error and not alias.warned:
-                warn(_('warning: %s\n') % (alias.error))
+                warn(_(b'warning: %s\n') % (alias.error))
                 alias.warned = True
     return tree
 
@@ -613,24 +615,24 @@
     """Fold elements to be concatenated by `##`
     """
     if not isinstance(tree, tuple) or tree[0] in (
-        'string',
-        'symbol',
-        'smartset',
+        b'string',
+        b'symbol',
+        b'smartset',
     ):
         return tree
-    if tree[0] == '_concat':
+    if tree[0] == b'_concat':
         pending = [tree]
         l = []
         while pending:
             e = pending.pop()
-            if e[0] == '_concat':
+            if e[0] == b'_concat':
                 pending.extend(reversed(e[1:]))
-            elif e[0] in ('string', 'symbol'):
+            elif e[0] in (b'string', b'symbol'):
                 l.append(e[1])
             else:
-                msg = _("\"##\" can't concatenate \"%s\" element") % (e[0])
+                msg = _(b"\"##\" can't concatenate \"%s\" element") % (e[0])
                 raise error.ParseError(msg)
-        return ('string', ''.join(l))
+        return (b'string', b''.join(l))
     else:
         return tuple(foldconcat(t) for t in tree)
 
@@ -642,12 +644,12 @@
         if len(inst.args) > 1:  # has location
             loc = inst.args[1]
             # Remove newlines -- spaces are equivalent whitespace.
-            spec = spec.replace('\n', ' ')
+            spec = spec.replace(b'\n', b' ')
             # We want the caret to point to the place in the template that
             # failed to parse, but in a hint we get a open paren at the
             # start. Therefore, we print "loc + 1" spaces (instead of "loc")
             # to line up the caret with the location of the error.
-            inst.hint = spec + '\n' + ' ' * (loc + 1) + '^ ' + _('here')
+            inst.hint = spec + b'\n' + b' ' * (loc + 1) + b'^ ' + _(b'here')
         raise
 
 
@@ -663,70 +665,70 @@
     >>> _quote(1)
     "'1'"
     """
-    return "'%s'" % stringutil.escapestr(pycompat.bytestr(s))
+    return b"'%s'" % stringutil.escapestr(pycompat.bytestr(s))
 
 
 def _formatargtype(c, arg):
-    if c == 'd':
-        return '_rev(%d)' % int(arg)
-    elif c == 's':
+    if c == b'd':
+        return b'_rev(%d)' % int(arg)
+    elif c == b's':
         return _quote(arg)
-    elif c == 'r':
+    elif c == b'r':
         if not isinstance(arg, bytes):
             raise TypeError
         parse(arg)  # make sure syntax errors are confined
-        return '(%s)' % arg
-    elif c == 'n':
+        return b'(%s)' % arg
+    elif c == b'n':
         return _quote(node.hex(arg))
-    elif c == 'b':
+    elif c == b'b':
         try:
             return _quote(arg.branch())
         except AttributeError:
             raise TypeError
-    raise error.ParseError(_('unexpected revspec format character %s') % c)
+    raise error.ParseError(_(b'unexpected revspec format character %s') % c)
 
 
 def _formatlistexp(s, t):
     l = len(s)
     if l == 0:
-        return "_list('')"
+        return b"_list('')"
     elif l == 1:
         return _formatargtype(t, s[0])
-    elif t == 'd':
+    elif t == b'd':
         return _formatintlist(s)
-    elif t == 's':
-        return "_list(%s)" % _quote("\0".join(s))
-    elif t == 'n':
-        return "_hexlist('%s')" % "\0".join(node.hex(a) for a in s)
-    elif t == 'b':
+    elif t == b's':
+        return b"_list(%s)" % _quote(b"\0".join(s))
+    elif t == b'n':
+        return b"_hexlist('%s')" % b"\0".join(node.hex(a) for a in s)
+    elif t == b'b':
         try:
-            return "_list('%s')" % "\0".join(a.branch() for a in s)
+            return b"_list('%s')" % b"\0".join(a.branch() for a in s)
         except AttributeError:
             raise TypeError
 
     m = l // 2
-    return '(%s or %s)' % (_formatlistexp(s[:m], t), _formatlistexp(s[m:], t))
+    return b'(%s or %s)' % (_formatlistexp(s[:m], t), _formatlistexp(s[m:], t))
 
 
 def _formatintlist(data):
     try:
         l = len(data)
         if l == 0:
-            return "_list('')"
+            return b"_list('')"
         elif l == 1:
-            return _formatargtype('d', data[0])
-        return "_intlist('%s')" % "\0".join('%d' % int(a) for a in data)
+            return _formatargtype(b'd', data[0])
+        return b"_intlist('%s')" % b"\0".join(b'%d' % int(a) for a in data)
     except (TypeError, ValueError):
-        raise error.ParseError(_('invalid argument for revspec'))
+        raise error.ParseError(_(b'invalid argument for revspec'))
 
 
 def _formatparamexp(args, t):
-    return ', '.join(_formatargtype(t, a) for a in args)
+    return b', '.join(_formatargtype(t, a) for a in args)
 
 
 _formatlistfuncs = {
-    'l': _formatlistexp,
-    'p': _formatparamexp,
+    b'l': _formatlistexp,
+    b'p': _formatparamexp,
 }
 
 
@@ -772,12 +774,12 @@
     for t, arg in parsed:
         if t is None:
             ret.append(arg)
-        elif t == 'baseset':
+        elif t == b'baseset':
             if isinstance(arg, set):
                 arg = sorted(arg)
             ret.append(_formatintlist(list(arg)))
         else:
-            raise error.ProgrammingError("unknown revspec item type: %r" % t)
+            raise error.ProgrammingError(b"unknown revspec item type: %r" % t)
     return b''.join(ret)
 
 
@@ -789,15 +791,15 @@
     for t, arg in parsed:
         if t is None:
             ret.append(arg)
-        elif t == 'baseset':
-            newtree = ('smartset', smartset.baseset(arg))
+        elif t == b'baseset':
+            newtree = (b'smartset', smartset.baseset(arg))
             inputs.append(newtree)
-            ret.append("$")
+            ret.append(b"$")
         else:
-            raise error.ProgrammingError("unknown revspec item type: %r" % t)
+            raise error.ProgrammingError(b"unknown revspec item type: %r" % t)
     expr = b''.join(ret)
     tree = _parsewith(expr, syminitletters=_aliassyminitletters)
-    tree = parser.buildtree(tree, ('symbol', '$'), *inputs)
+    tree = parser.buildtree(tree, (b'symbol', b'$'), *inputs)
     tree = foldconcat(tree)
     tree = analyze(tree)
     tree = optimize(tree)
@@ -818,7 +820,7 @@
     ret = []
     pos = 0
     while pos < len(expr):
-        q = expr.find('%', pos)
+        q = expr.find(b'%', pos)
         if q < 0:
             ret.append((None, expr[pos:]))
             break
@@ -827,8 +829,8 @@
         try:
             d = expr[pos]
         except IndexError:
-            raise error.ParseError(_('incomplete revspec format character'))
-        if d == '%':
+            raise error.ParseError(_(b'incomplete revspec format character'))
+        if d == b'%':
             ret.append((None, d))
             pos += 1
             continue
@@ -836,45 +838,47 @@
         try:
             arg = next(argiter)
         except StopIteration:
-            raise error.ParseError(_('missing argument for revspec'))
+            raise error.ParseError(_(b'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'
+            islist = d == b'l'
             try:
                 d = expr[pos]
             except IndexError:
-                raise error.ParseError(_('incomplete revspec format character'))
-            if islist and d == 'd' and arg:
+                raise error.ParseError(
+                    _(b'incomplete revspec format character')
+                )
+            if islist and d == b'd' and arg:
                 # 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))
+                ret.append((b'baseset', arg))
                 pos += 1
                 continue
             try:
                 ret.append((None, f(list(arg), d)))
             except (TypeError, ValueError):
-                raise error.ParseError(_('invalid argument for revspec'))
+                raise error.ParseError(_(b'invalid argument for revspec'))
         else:
             # a single entry, not expensive, replace
             try:
                 ret.append((None, _formatargtype(d, arg)))
             except (TypeError, ValueError):
-                raise error.ParseError(_('invalid argument for revspec'))
+                raise error.ParseError(_(b'invalid argument for revspec'))
         pos += 1
 
     try:
         next(argiter)
-        raise error.ParseError(_('too many revspec arguments specified'))
+        raise error.ParseError(_(b'too many revspec arguments specified'))
     except StopIteration:
         pass
     return ret
 
 
 def prettyformat(tree):
-    return parser.prettyformat(tree, ('string', 'symbol'))
+    return parser.prettyformat(tree, (b'string', b'symbol'))
 
 
 def depth(tree):
@@ -885,18 +889,18 @@
 
 
 def funcsused(tree):
-    if not isinstance(tree, tuple) or tree[0] in ('string', 'symbol'):
+    if not isinstance(tree, tuple) or tree[0] in (b'string', b'symbol'):
         return set()
     else:
         funcs = set()
         for s in tree[1:]:
             funcs |= funcsused(s)
-        if tree[0] == 'func':
+        if tree[0] == b'func':
             funcs.add(tree[1][1])
         return funcs
 
 
-_hashre = util.re.compile('[0-9a-fA-F]{1,40}$')
+_hashre = util.re.compile(b'[0-9a-fA-F]{1,40}$')
 
 
 def _ishashlikesymbol(symbol):
@@ -919,7 +923,7 @@
     if not tree:
         return []
 
-    if tree[0] == "symbol":
+    if tree[0] == b"symbol":
         if _ishashlikesymbol(tree[1]):
             return [tree[1]]
     elif len(tree) >= 3: