mercurial: comparison tests/test-revset.t

equal deleted inserted replaced

-:30535fe47e78
+:7bbc4e113e5f
 trivial
 $ try 0:1
 (range
-('symbol', '0')
+(symbol '0')
-('symbol', '1'))
+(symbol '1'))
 * set:
 <spanset+ 0:2>
 0
 1
 $ try --optimize :
 7
 8
 9
 $ try 3::6
 (dagrange
-('symbol', '3')
+(symbol '3')
-('symbol', '6'))
+(symbol '6'))
 * set:
 <baseset+ [3, 5, 6]>
 3
 5
 6
 $ try '0|1|2'
 (or
 (list
-('symbol', '0')
+(symbol '0')
-('symbol', '1')
+(symbol '1')
-('symbol', '2')))
+(symbol '2')))
 * set:
 <baseset [0, 1, 2]>
 0
 1
 2
 names that should work without quoting
 $ try a
-('symbol', 'a')
+(symbol 'a')
 * set:
 <baseset [0]>
 0
 $ try b-a
 (minus
-('symbol', 'b')
+(symbol 'b')
-('symbol', 'a'))
+(symbol 'a'))
 * set:
 <filteredset
 <baseset [1]>,
 <not
 <baseset [0]>>>
 1
 $ try _a_b_c_
-('symbol', '_a_b_c_')
+(symbol '_a_b_c_')
 * set:
 <baseset [6]>
 6
 $ try _a_b_c_-a
 (minus
-('symbol', '_a_b_c_')
+(symbol '_a_b_c_')
-('symbol', 'a'))
+(symbol 'a'))
 * set:
 <filteredset
 <baseset [6]>,
 <not
 <baseset [0]>>>
 6
 $ try .a.b.c.
-('symbol', '.a.b.c.')
+(symbol '.a.b.c.')
 * set:
 <baseset [7]>
 7
 $ try .a.b.c.-a
 (minus
-('symbol', '.a.b.c.')
+(symbol '.a.b.c.')
-('symbol', 'a'))
+(symbol 'a'))
 * set:
 <filteredset
 <baseset [7]>,
 <not
 <baseset [0]>>>
 7
 names that should be caught by fallback mechanism
 $ try -- '-a-b-c-'
-('symbol', '-a-b-c-')
+(symbol '-a-b-c-')
 * set:
 <baseset [4]>
 4
 $ log -a-b-c-
 4
 $ try '+a+b+c+'
-('symbol', '+a+b+c+')
+(symbol '+a+b+c+')
 * set:
 <baseset [3]>
 3
 $ try '+a+b+c+:'
 (rangepost
-('symbol', '+a+b+c+'))
+(symbol '+a+b+c+'))
 * set:
 <spanset+ 3:10>
 3
 4
 5
 7
 8
 9
 $ try ':+a+b+c+'
 (rangepre
-('symbol', '+a+b+c+'))
+(symbol '+a+b+c+'))
 * set:
 <spanset+ 0:4>
 0
 1
 2
 3
 $ try -- '-a-b-c-:+a+b+c+'
 (range
-('symbol', '-a-b-c-')
+(symbol '-a-b-c-')
-('symbol', '+a+b+c+'))
+(symbol '+a+b+c+'))
 * set:
 <spanset- 3:5>
 4
 3
 $ log '-a-b-c-:+a+b+c+'
 $ try -- -a-b-c--a # complains
 (minus
 (minus
 (minus
 (negate
-('symbol', 'a'))
+(symbol 'a'))
-('symbol', 'b'))
+(symbol 'b'))
-('symbol', 'c'))
+(symbol 'c'))
 (negate
-('symbol', 'a')))
+(symbol 'a')))
 abort: unknown revision '-a'!
 [255]
 $ try é
-('symbol', '\xc3\xa9')
+(symbol '\xc3\xa9')
 * set:
 <baseset [9]>
 9
 no quoting needed
 quoting needed
 $ try '"-a-b-c-"-a'
 (minus
-('string', '-a-b-c-')
+(string '-a-b-c-')
-('symbol', 'a'))
+(symbol 'a'))
 * set:
 <filteredset
 <baseset [4]>,
 <not
 <baseset [0]>>>
 $ log '1&2'
 $ try '1&2|3' # precedence - and is higher
 (or
 (list
 (and
-('symbol', '1')
+(symbol '1')
-('symbol', '2'))
+(symbol '2'))
-('symbol', '3')))
+(symbol '3')))
 * set:
 <addset
 <baseset []>,
 <baseset [3]>>
 3
 $ try '1|2&3'
 (or
 (list
-('symbol', '1')
+(symbol '1')
 (and
-('symbol', '2')
+(symbol '2')
-('symbol', '3'))))
+(symbol '3'))))
 * set:
 <addset
 <baseset [1]>,
 <baseset []>>
 1
 $ try '1&2&3' # associativity
 (and
 (and
-('symbol', '1')
+(symbol '1')
-('symbol', '2'))
+(symbol '2'))
-('symbol', '3'))
+(symbol '3'))
 * set:
 <baseset []>
 $ try '1|(2|3)'
 (or
 (list
-('symbol', '1')
+(symbol '1')
 (group
 (or
 (list
-('symbol', '2')
+(symbol '2')
-('symbol', '3'))))))
+(symbol '3'))))))
 * set:
 <addset
 <baseset [1]>,
 <baseset [2, 3]>>
 1
 hg: parse error: extra got an unexpected keyword argument 'unknown'
 [255]
 $ try 'foo=bar|baz'
 (keyvalue
-('symbol', 'foo')
+(symbol 'foo')
 (or
 (list
-('symbol', 'bar')
+(symbol 'bar')
-('symbol', 'baz'))))
+(symbol 'baz'))))
 hg: parse error: can't use a key-value pair in this context
 [255]
 right-hand side should be optimized recursively
 $ try --optimize 'foo=(not public())'
 (keyvalue
-('symbol', 'foo')
+(symbol 'foo')
 (group
 (not
 (func
-('symbol', 'public')
+(symbol 'public')
 None))))
 * optimized:
 (keyvalue
-('symbol', 'foo')
+(symbol 'foo')
 (func
-('symbol', '_notpublic')
+(symbol '_notpublic')
 None))
 hg: parse error: can't use a key-value pair in this context
 [255]
 relation-subscript operator has the highest binding strength (as function call):
 $ hg debugrevspec -p parsed 'tip:tip^#generations[-1]'
 * parsed:
 (range
-('symbol', 'tip')
+(symbol 'tip')
 (relsubscript
 (parentpost
-('symbol', 'tip'))
+(symbol 'tip'))
-('symbol', 'generations')
+(symbol 'generations')
 (negate
-('symbol', '1'))))
+(symbol '1'))))
 9
 8
 7
 6
 5
 $ hg debugrevspec -p parsed --no-show-revs 'not public()#generations[0]'
 * parsed:
 (not
 (relsubscript
 (func
-('symbol', 'public')
+(symbol 'public')
 None)
-('symbol', 'generations')
+(symbol 'generations')
-('symbol', '0')))
+(symbol '0')))
 left-hand side of relation-subscript operator should be optimized recursively:
 $ hg debugrevspec -p analyzed -p optimized --no-show-revs \
 > '(not public())#generations[0]'
 * analyzed:
 (relsubscript
 (not
 (func
-('symbol', 'public')
+(symbol 'public')
 None))
-('symbol', 'generations')
+(symbol 'generations')
-('symbol', '0'))
+(symbol '0'))
 * optimized:
 (relsubscript
 (func
-('symbol', '_notpublic')
+(symbol '_notpublic')
 None)
-('symbol', 'generations')
+(symbol 'generations')
-('symbol', '0'))
+(symbol '0'))
 resolution of subscript and relation-subscript ternary operators:
 $ hg debugrevspec -p analyzed 'tip[0]'
 * analyzed:
 (subscript
-('symbol', 'tip')
+(symbol 'tip')
-('symbol', '0'))
+(symbol '0'))
 hg: parse error: can't use a subscript in this context
 [255]
 $ hg debugrevspec -p analyzed 'tip#rel[0]'
 * analyzed:
 (relsubscript
-('symbol', 'tip')
+(symbol 'tip')
-('symbol', 'rel')
+(symbol 'rel')
-('symbol', '0'))
+(symbol '0'))
 hg: parse error: unknown identifier: rel
 [255]
 $ hg debugrevspec -p analyzed '(tip#rel)[0]'
 * analyzed:
 (subscript
 (relation
-('symbol', 'tip')
+(symbol 'tip')
-('symbol', 'rel'))
+(symbol 'rel'))
-('symbol', '0'))
+(symbol '0'))
 hg: parse error: can't use a subscript in this context
 [255]
 $ hg debugrevspec -p analyzed 'tip#rel[0][1]'
 * analyzed:
 (subscript
 (relsubscript
-('symbol', 'tip')
+(symbol 'tip')
-('symbol', 'rel')
+(symbol 'rel')
-('symbol', '0'))
+(symbol '0'))
-('symbol', '1'))
+(symbol '1'))
 hg: parse error: can't use a subscript in this context
 [255]
 $ hg debugrevspec -p analyzed 'tip#rel0#rel1[1]'
 * analyzed:
 (relsubscript
 (relation
-('symbol', 'tip')
+(symbol 'tip')
-('symbol', 'rel0'))
+(symbol 'rel0'))
-('symbol', 'rel1')
+(symbol 'rel1')
-('symbol', '1'))
+(symbol '1'))
 hg: parse error: unknown identifier: rel1
 [255]
 $ hg debugrevspec -p analyzed 'tip#rel0[0]#rel1[1]'
 * analyzed:
 (relsubscript
 (relsubscript
-('symbol', 'tip')
+(symbol 'tip')
-('symbol', 'rel0')
+(symbol 'rel0')
-('symbol', '0'))
+(symbol '0'))
-('symbol', 'rel1')
+(symbol 'rel1')
-('symbol', '1'))
+(symbol '1'))
 hg: parse error: unknown identifier: rel1
 [255]
 parse errors of relation, subscript and relation-subscript operators:
 * parsed:
 (minus
 (group
 (or
 (list
-('symbol', '0')
+(symbol '0')
-('symbol', '1'))))
+(symbol '1'))))
-('symbol', '1'))
+(symbol '1'))
 * analyzed:
 (and
 (or
 (list
-('symbol', '0')
+(symbol '0')
-('symbol', '1')))
+(symbol '1')))
 (not
-('symbol', '1')))
+(symbol '1')))
 * optimized:
 (difference
 (func
-('symbol', '_list')
+(symbol '_list')
-('string', '0\x001'))
+(string '0\x001'))
-('symbol', '1'))
+(symbol '1'))
 0
 $ hg debugrevspec -p unknown '0'
 abort: invalid stage name: unknown
 [255]
 $ hg debugrevspec --verify -v -p analyzed -p optimized 'r3232() & 2'
 * analyzed:
 (and
 (func
-('symbol', 'r3232')
+(symbol 'r3232')
 None)
-('symbol', '2'))
+(symbol '2'))
 * optimized:
 (andsmally
 (func
-('symbol', 'r3232')
+(symbol 'r3232')
 None)
-('symbol', '2'))
+(symbol '2'))
 * analyzed set:
 <baseset [2]>
 * optimized set:
 <baseset [2, 2]>
 --- analyzed
 8
 9
 $ try -p analyzed ':1'
 * analyzed:
 (rangepre
-('symbol', '1'))
+(symbol '1'))
 * set:
 <spanset+ 0:2>
 0
 1
 $ try -p analyzed ':(1|2)'
 * analyzed:
 (rangepre
 (or
 (list
-('symbol', '1')
+(symbol '1')
-('symbol', '2'))))
+(symbol '2'))))
 * set:
 <spanset+ 0:3>
 0
 1
 2
 $ try -p analyzed ':(1&2)'
 * analyzed:
 (rangepre
 (and
-('symbol', '1')
+(symbol '1')
-('symbol', '2')))
+(symbol '2')))
 * set:
 <baseset []>
 infix/suffix resolution of ^ operator (issue2884):
 x^:y means (x^):y
 $ try '1^:2'
 (range
 (parentpost
-('symbol', '1'))
+(symbol '1'))
-('symbol', '2'))
+(symbol '2'))
 * set:
 <spanset+ 0:3>
 0
 1
 2
 $ try '1^::2'
 (dagrange
 (parentpost
-('symbol', '1'))
+(symbol '1'))
-('symbol', '2'))
+(symbol '2'))
 * set:
 <baseset+ [0, 1, 2]>
 0
 1
 2
 $ try '9^:'
 (rangepost
 (parentpost
-('symbol', '9')))
+(symbol '9')))
 * set:
 <spanset+ 8:10>
 8
 9
 x^:y should be resolved before omitting group operators
 $ try '1^(:2)'
 (parent
-('symbol', '1')
+(symbol '1')
 (group
 (rangepre
-('symbol', '2'))))
+(symbol '2'))))
 hg: parse error: ^ expects a number 0, 1, or 2
 [255]
 x^:y should be resolved recursively
 $ try 'sort(1^:2)'
 (func
-('symbol', 'sort')
+(symbol 'sort')
 (range
 (parentpost
-('symbol', '1'))
+(symbol '1'))
-('symbol', '2')))
+(symbol '2')))
 * set:
 <spanset+ 0:3>
 0
 1
 2
 (range
 (parentpost
 (group
 (range
 (parentpost
-('symbol', '3'))
+(symbol '3'))
-('symbol', '4'))))
+(symbol '4'))))
-('symbol', '2'))
+(symbol '2'))
 * set:
 <spanset+ 0:3>
 0
 1
 2
 (dagrange
 (parentpost
 (group
 (dagrange
 (parentpost
-('symbol', '3'))
+(symbol '3'))
-('symbol', '4'))))
+(symbol '4'))))
-('symbol', '2'))
+(symbol '2'))
 * set:
 <baseset+ [0, 1, 2]>
 0
 1
 2
 (rangepost
 (parentpost
 (group
 (rangepost
 (parentpost
-('symbol', '9'))))))
+(symbol '9'))))))
 * set:
 <spanset+ 4:10>
 4
 5
 6
 9
 x^ in alias should also be resolved
 $ try 'A' --config 'revsetalias.A=1^:2'
-('symbol', 'A')
+(symbol 'A')
 * expanded:
 (range
 (parentpost
-('symbol', '1'))
+(symbol '1'))
-('symbol', '2'))
+(symbol '2'))
 * set:
 <spanset+ 0:3>
 0
 1
 2
 $ try 'A:2' --config 'revsetalias.A=1^'
 (range
-('symbol', 'A')
+(symbol 'A')
-('symbol', '2'))
+(symbol '2'))
 * expanded:
 (range
 (parentpost
-('symbol', '1'))
+(symbol '1'))
-('symbol', '2'))
+(symbol '2'))
 * set:
 <spanset+ 0:3>
 0
 1
 2
 but not beyond the boundary of alias expansion, because the resolution should
 be made at the parsing stage
 $ try '1^A' --config 'revsetalias.A=:2'
 (parent
-('symbol', '1')
+(symbol '1')
-('symbol', 'A'))
+(symbol 'A'))
 * expanded:
 (parent
-('symbol', '1')
+(symbol '1')
 (rangepre
-('symbol', '2')))
+(symbol '2')))
 hg: parse error: ^ expects a number 0, 1, or 2
 [255]
 ancestor can accept 0 or more arguments
 $ hg debugrevspec -p parsed 'roots(:)#g[2]'
 * parsed:
 (relsubscript
 (func
-('symbol', 'roots')
+(symbol 'roots')
 (rangeall
 None))
-('symbol', 'g')
+(symbol 'g')
-('symbol', '2'))
+(symbol '2'))
 2
 3
 test author
 9
 $ log 'grep("issue\d+")'
 6
 $ try 'grep("(")' # invalid regular expression
 (func
-('symbol', 'grep')
+(symbol 'grep')
-('string', '('))
+(string '('))
 hg: parse error: invalid match pattern: unbalanced parenthesis
 [255]
 $ try 'grep("\bissue\d+")'
 (func
-('symbol', 'grep')
+(symbol 'grep')
-('string', '\x08issue\\d+'))
+(string '\x08issue\\d+'))
 * set:
 <filteredset
 <fullreposet+ 0:10>,
 <grep '\x08issue\\d+'>>
 $ try 'grep(r"\bissue\d+")'
 (func
-('symbol', 'grep')
+(symbol 'grep')
-('string', '\\bissue\\d+'))
+(string '\\bissue\\d+'))
 * set:
 <filteredset
 <fullreposet+ 0:10>,
 <grep '\\bissue\\d+'>>
 6
 $ try --optimize '8:9-8%'
 (onlypost
 (minus
 (range
-('symbol', '8')
+(symbol '8')
-('symbol', '9'))
+(symbol '9'))
-('symbol', '8')))
+(symbol '8')))
 * optimized:
 (func
-('symbol', 'only')
+(symbol 'only')
 (difference
 (range
-('symbol', '8')
+(symbol '8')
-('symbol', '9'))
+(symbol '9'))
-('symbol', '8')))
+(symbol '8')))
 * set:
 <baseset+ [8, 9]>
 8
 9
 $ try --optimize '(9)%(5)'
 (only
 (group
-('symbol', '9'))
+(symbol '9'))
 (group
-('symbol', '5')))
+(symbol '5')))
 * optimized:
 (func
-('symbol', 'only')
+(symbol 'only')
 (list
-('symbol', '9')
+(symbol '9')
-('symbol', '5')))
+(symbol '5')))
 * set:
 <baseset+ [2, 4, 8, 9]>
 2
 4
 8
 $ try -p optimized '3:0 & 0:3 & not 2:1'
 * optimized:
 (difference
 (and
 (range
-('symbol', '3')
+(symbol '3')
-('symbol', '0'))
+(symbol '0'))
 (range
-('symbol', '0')
+(symbol '0')
-('symbol', '3')))
+(symbol '3')))
 (range
-('symbol', '2')
+(symbol '2')
-('symbol', '1')))
+(symbol '1')))
 * set:
 <filteredset
 <filteredset
 <spanset- 0:4>,
 <spanset+ 0:4>>,
 the left expression:
 $ try --optimize '2:0 & (0 + 1 + 2)'
 (and
 (range
-('symbol', '2')
+(symbol '2')
-('symbol', '0'))
+(symbol '0'))
 (group
 (or
 (list
-('symbol', '0')
+(symbol '0')
-('symbol', '1')
+(symbol '1')
-('symbol', '2')))))
+(symbol '2')))))
 * optimized:
 (and
 (range
-('symbol', '2')
+(symbol '2')
-('symbol', '0'))
+(symbol '0'))
 (func
-('symbol', '_list')
+(symbol '_list')
-('string', '0\x001\x002')))
+(string '0\x001\x002')))
 * set:
 <filteredset
 <spanset- 0:3>,
 <baseset [0, 1, 2]>>
 2
 'A + B' should take the ordering of the left expression:
 $ try --optimize '2:0 & (0:1 + 2)'
 (and
 (range
-('symbol', '2')
+(symbol '2')
-('symbol', '0'))
+(symbol '0'))
 (group
 (or
 (list
 (range
-('symbol', '0')
+(symbol '0')
-('symbol', '1'))
+(symbol '1'))
-('symbol', '2')))))
+(symbol '2')))))
 * optimized:
 (and
 (range
-('symbol', '2')
+(symbol '2')
-('symbol', '0'))
+(symbol '0'))
 (or
 (list
 (range
-('symbol', '0')
+(symbol '0')
-('symbol', '1'))
+(symbol '1'))
-('symbol', '2'))))
+(symbol '2'))))
 * set:
 <filteredset
 <spanset- 0:3>,
 <addset
 <spanset+ 0:2>,
 '_intlist(a b)' should behave like 'a + b':
 $ trylist --optimize '2:0 & %ld' 0 1 2
 (and
 (range
-('symbol', '2')
+(symbol '2')
-('symbol', '0'))
+(symbol '0'))
 (func
-('symbol', '_intlist')
+(symbol '_intlist')
-('string', '0\x001\x002')))
+(string '0\x001\x002')))
 * optimized:
 (andsmally
 (range
-('symbol', '2')
+(symbol '2')
-('symbol', '0'))
+(symbol '0'))
 (func
-('symbol', '_intlist')
+(symbol '_intlist')
-('string', '0\x001\x002')))
+(string '0\x001\x002')))
 * set:
 <filteredset
 <spanset- 0:3>,
 <baseset+ [0, 1, 2]>>
 2
 0
 $ trylist --optimize '%ld & 2:0' 0 2 1
 (and
 (func
-('symbol', '_intlist')
+(symbol '_intlist')
-('string', '0\x002\x001'))
+(string '0\x002\x001'))
 (range
-('symbol', '2')
+(symbol '2')
-('symbol', '0')))
+(symbol '0')))
 * optimized:
 (and
 (func
-('symbol', '_intlist')
+(symbol '_intlist')
-('string', '0\x002\x001'))
+(string '0\x002\x001'))
 (range
-('symbol', '2')
+(symbol '2')
-('symbol', '0')))
+(symbol '0')))
 * set:
 <filteredset
 <baseset [0, 2, 1]>,
 <spanset- 0:3>>
 0
 '_hexlist(a b)' should behave like 'a + b':
 $ trylist --optimize --bin '2:0 & %ln' `hg log -T '{node} ' -r0:2`
 (and
 (range
-('symbol', '2')
+(symbol '2')
-('symbol', '0'))
+(symbol '0'))
 (func
-('symbol', '_hexlist')
+(symbol '_hexlist')
-('string', '*'))) (glob)
+(string '*'))) (glob)
 * optimized:
 (and
 (range
-('symbol', '2')
+(symbol '2')
-('symbol', '0'))
+(symbol '0'))
 (func
-('symbol', '_hexlist')
+(symbol '_hexlist')
-('string', '*'))) (glob)
+(string '*'))) (glob)
 * set:
 <filteredset
 <spanset- 0:3>,
 <baseset [0, 1, 2]>>
 2
 0
 $ trylist --optimize --bin '%ln & 2:0' `hg log -T '{node} ' -r0+2+1`
 (and
 (func
-('symbol', '_hexlist')
+(symbol '_hexlist')
-('string', '*')) (glob)
+(string '*')) (glob)
 (range
-('symbol', '2')
+(symbol '2')
-('symbol', '0')))
+(symbol '0')))
 * optimized:
 (andsmally
 (func
-('symbol', '_hexlist')
+(symbol '_hexlist')
-('string', '*')) (glob)
+(string '*')) (glob)
 (range
-('symbol', '2')
+(symbol '2')
-('symbol', '0')))
+(symbol '0')))
 * set:
 <baseset [0, 2, 1]>
 0
 2
 1
 $ try -p optimized '2:0 & not (0 + 1)'
 * optimized:
 (difference
 (range
-('symbol', '2')
+(symbol '2')
-('symbol', '0'))
+(symbol '0'))
 (func
-('symbol', '_list')
+(symbol '_list')
-('string', '0\x001')))
+(string '0\x001')))
 * set:
 <filteredset
 <spanset- 0:3>,
 <not
 <baseset [0, 1]>>>
 $ try -p optimized '2:0 & not (0:2 & (0 + 1))'
 * optimized:
 (difference
 (range
-('symbol', '2')
+(symbol '2')
-('symbol', '0'))
+(symbol '0'))
 (and
 (range
-('symbol', '0')
+(symbol '0')
-('symbol', '2'))
+(symbol '2'))
 (func
-('symbol', '_list')
+(symbol '_list')
-('string', '0\x001'))))
+(string '0\x001'))))
 * set:
 <filteredset
 <spanset- 0:3>,
 <not
 <baseset [0, 1]>>>
 ordering requirement should be forwarded to the nested expression
 $ try -p optimized 'present(2 + 0 + 1)'
 * optimized:
 (func
-('symbol', 'present')
+(symbol 'present')
 (func
-('symbol', '_list')
+(symbol '_list')
-('string', '2\x000\x001')))
+(string '2\x000\x001')))
 * set:
 <baseset [2, 0, 1]>
 2
 0
 1
 $ try --optimize '2:0 & present(0 + 1 + 2)'
 (and
 (range
-('symbol', '2')
+(symbol '2')
-('symbol', '0'))
+(symbol '0'))
 (func
-('symbol', 'present')
+(symbol 'present')
 (or
 (list
-('symbol', '0')
+(symbol '0')
-('symbol', '1')
+(symbol '1')
-('symbol', '2')))))
+(symbol '2')))))
 * optimized:
 (and
 (range
-('symbol', '2')
+(symbol '2')
-('symbol', '0'))
+(symbol '0'))
 (func
-('symbol', 'present')
+(symbol 'present')
 (func
-('symbol', '_list')
+(symbol '_list')
-('string', '0\x001\x002'))))
+(string '0\x001\x002'))))
 * set:
 <filteredset
 <spanset- 0:3>,
 <baseset [0, 1, 2]>>
 2
 'reverse()' should take effect only if it is the outermost expression:
 $ try --optimize '0:2 & reverse(all())'
 (and
 (range
-('symbol', '0')
+(symbol '0')
-('symbol', '2'))
+(symbol '2'))
 (func
-('symbol', 'reverse')
+(symbol 'reverse')
 (func
-('symbol', 'all')
+(symbol 'all')
 None)))
 * optimized:
 (and
 (range
-('symbol', '0')
+(symbol '0')
-('symbol', '2'))
+(symbol '2'))
 (func
-('symbol', 'reverse')
+(symbol 'reverse')
 (func
-('symbol', 'all')
+(symbol 'all')
 None)))
 * set:
 <filteredset
 <spanset+ 0:3>,
 <spanset+ 0:10>>
 'sort()' should take effect only if it is the outermost expression:
 $ try --optimize '0:2 & sort(all(), -rev)'
 (and
 (range
-('symbol', '0')
+(symbol '0')
-('symbol', '2'))
+(symbol '2'))
 (func
-('symbol', 'sort')
+(symbol 'sort')
 (list
 (func
-('symbol', 'all')
+(symbol 'all')
 None)
 (negate
-('symbol', 'rev')))))
+(symbol 'rev')))))
 * optimized:
 (and
 (range
-('symbol', '0')
+(symbol '0')
-('symbol', '2'))
+(symbol '2'))
 (func
-('symbol', 'sort')
+(symbol 'sort')
 (list
 (func
-('symbol', 'all')
+(symbol 'all')
 None)
-('string', '-rev'))))
+(string '-rev'))))
 * set:
 <filteredset
 <spanset+ 0:3>,
 <spanset+ 0:10>>
 0
 for 'A & f(B)', 'B' should not be affected by the order of 'A':
 $ try --optimize '2:0 & first(1 + 0 + 2)'
 (and
 (range
-('symbol', '2')
+(symbol '2')
-('symbol', '0'))
+(symbol '0'))
 (func
-('symbol', 'first')
+(symbol 'first')
 (or
 (list
-('symbol', '1')
+(symbol '1')
-('symbol', '0')
+(symbol '0')
-('symbol', '2')))))
+(symbol '2')))))
 * optimized:
 (and
 (range
-('symbol', '2')
+(symbol '2')
-('symbol', '0'))
+(symbol '0'))
 (func
-('symbol', 'first')
+(symbol 'first')
 (func
-('symbol', '_list')
+(symbol '_list')
-('string', '1\x000\x002'))))
+(string '1\x000\x002'))))
 * set:
 <filteredset
 <baseset [1]>,
 <spanset- 0:3>>
 1
 $ try --optimize '2:0 & not last(0 + 2 + 1)'
 (and
 (range
-('symbol', '2')
+(symbol '2')
-('symbol', '0'))
+(symbol '0'))
 (not
 (func
-('symbol', 'last')
+(symbol 'last')
 (or
 (list
-('symbol', '0')
+(symbol '0')
-('symbol', '2')
+(symbol '2')
-('symbol', '1'))))))
+(symbol '1'))))))
 * optimized:
 (difference
 (range
-('symbol', '2')
+(symbol '2')
-('symbol', '0'))
+(symbol '0'))
 (func
-('symbol', 'last')
+(symbol 'last')
 (func
-('symbol', '_list')
+(symbol '_list')
-('string', '0\x002\x001'))))
+(string '0\x002\x001'))))
 * set:
 <filteredset
 <spanset- 0:3>,
 <not
 <baseset [1]>>>
 for 'A & (op)(B)', 'B' should not be affected by the order of 'A':
 $ try --optimize '2:0 & (1 + 0 + 2):(0 + 2 + 1)'
 (and
 (range
-('symbol', '2')
+(symbol '2')
-('symbol', '0'))
+(symbol '0'))
 (range
 (group
 (or
 (list
-('symbol', '1')
+(symbol '1')
-('symbol', '0')
+(symbol '0')
-('symbol', '2'))))
+(symbol '2'))))
 (group
 (or
 (list
-('symbol', '0')
+(symbol '0')
-('symbol', '2')
+(symbol '2')
-('symbol', '1'))))))
+(symbol '1'))))))
 * optimized:
 (and
 (range
-('symbol', '2')
+(symbol '2')
-('symbol', '0'))
+(symbol '0'))
 (range
 (func
-('symbol', '_list')
+(symbol '_list')
-('string', '1\x000\x002'))
+(string '1\x000\x002'))
 (func
-('symbol', '_list')
+(symbol '_list')
-('string', '0\x002\x001'))))
+(string '0\x002\x001'))))
 * set:
 <filteredset
 <spanset- 0:3>,
 <baseset [1]>>
 1
 'A & B' can be rewritten as 'flipand(B, A)' by weight.
 $ try --optimize 'contains("glob:*") & (2 + 0 + 1)'
 (and
 (func
-('symbol', 'contains')
+(symbol 'contains')
-('string', 'glob:*'))
+(string 'glob:*'))
 (group
 (or
 (list
-('symbol', '2')
+(symbol '2')
-('symbol', '0')
+(symbol '0')
-('symbol', '1')))))
+(symbol '1')))))
 * optimized:
 (andsmally
 (func
-('symbol', 'contains')
+(symbol 'contains')
-('string', 'glob:*'))
+(string 'glob:*'))
 (func
-('symbol', '_list')
+(symbol '_list')
-('string', '2\x000\x001')))
+(string '2\x000\x001')))
 * set:
 <filteredset
 <baseset+ [0, 1, 2]>,
 <contains 'glob:*'>>
 0
 the order appropriately:
 $ try --optimize 'reverse(contains("glob:*")) & (0 + 2 + 1)'
 (and
 (func
-('symbol', 'reverse')
+(symbol 'reverse')
 (func
-('symbol', 'contains')
+(symbol 'contains')
-('string', 'glob:*')))
+(string 'glob:*')))
 (group
 (or
 (list
-('symbol', '0')
+(symbol '0')
-('symbol', '2')
+(symbol '2')
-('symbol', '1')))))
+(symbol '1')))))
 * optimized:
 (andsmally
 (func
-('symbol', 'reverse')
+(symbol 'reverse')
 (func
-('symbol', 'contains')
+(symbol 'contains')
-('string', 'glob:*')))
+(string 'glob:*')))
 (func
-('symbol', '_list')
+(symbol '_list')
-('string', '0\x002\x001')))
+(string '0\x002\x001')))
 * set:
 <filteredset
 <baseset- [0, 1, 2]>,
 <contains 'glob:*'>>
 2
 $ try 'reverse(1::5) or ancestors(4)'
 (or
 (list
 (func
-('symbol', 'reverse')
+(symbol 'reverse')
 (dagrange
-('symbol', '1')
+(symbol '1')
-('symbol', '5')))
+(symbol '5')))
 (func
-('symbol', 'ancestors')
+(symbol 'ancestors')
-('symbol', '4'))))
+(symbol '4'))))
 * set:
 <addset
 <baseset- [1, 3, 5]>,
 <generatorset+>>
 5
 0
 2
 4
 $ try 'sort(ancestors(4) or reverse(1::5))'
 (func
-('symbol', 'sort')
+(symbol 'sort')
 (or
 (list
 (func
-('symbol', 'ancestors')
+(symbol 'ancestors')
-('symbol', '4'))
+(symbol '4'))
 (func
-('symbol', 'reverse')
+(symbol 'reverse')
 (dagrange
-('symbol', '1')
+(symbol '1')
-('symbol', '5'))))))
+(symbol '5'))))))
 * set:
 <addset+
 <generatorset+>,
 <baseset- [1, 3, 5]>>
 0
 test optimization of trivial `or` operation
 $ try --optimize '0|(1)|"2"|-2|tip|null'
 (or
 (list
-('symbol', '0')
+(symbol '0')
 (group
-('symbol', '1'))
+(symbol '1'))
-('string', '2')
+(string '2')
 (negate
-('symbol', '2'))
+(symbol '2'))
-('symbol', 'tip')
+(symbol 'tip')
-('symbol', 'null')))
+(symbol 'null')))
 * optimized:
 (func
-('symbol', '_list')
+(symbol '_list')
-('string', '0\x001\x002\x00-2\x00tip\x00null'))
+(string '0\x001\x002\x00-2\x00tip\x00null'))
 * set:
 <baseset [0, 1, 2, 8, 9, -1]>
 0
 1
 2
 -1
 $ try --optimize '0|1|2:3'
 (or
 (list
-('symbol', '0')
+(symbol '0')
-('symbol', '1')
+(symbol '1')
 (range
-('symbol', '2')
+(symbol '2')
-('symbol', '3'))))
+(symbol '3'))))
 * optimized:
 (or
 (list
 (func
-('symbol', '_list')
+(symbol '_list')
-('string', '0\x001'))
+(string '0\x001'))
 (range
-('symbol', '2')
+(symbol '2')
-('symbol', '3'))))
+(symbol '3'))))
 * set:
 <addset
 <baseset [0, 1]>,
 <spanset+ 2:4>>
 0
 $ try --optimize '0:1|2|3:4|5|6'
 (or
 (list
 (range
-('symbol', '0')
+(symbol '0')
-('symbol', '1'))
+(symbol '1'))
-('symbol', '2')
+(symbol '2')
 (range
-('symbol', '3')
+(symbol '3')
-('symbol', '4'))
+(symbol '4'))
-('symbol', '5')
+(symbol '5')
-('symbol', '6')))
+(symbol '6')))
 * optimized:
 (or
 (list
 (range
-('symbol', '0')
+(symbol '0')
-('symbol', '1'))
+(symbol '1'))
-('symbol', '2')
+(symbol '2')
 (range
-('symbol', '3')
+(symbol '3')
-('symbol', '4'))
+(symbol '4'))
 (func
-('symbol', '_list')
+(symbol '_list')
-('string', '5\x006'))))
+(string '5\x006'))))
 * set:
 <addset
 <addset
 <spanset+ 0:2>,
 <baseset [2]>>,
 $ try --no-optimized -p analyzed '0|1|2|3|4'
 * analyzed:
 (or
 (list
-('symbol', '0')
+(symbol '0')
-('symbol', '1')
+(symbol '1')
-('symbol', '2')
+(symbol '2')
-('symbol', '3')
+(symbol '3')
-('symbol', '4')))
+(symbol '4')))
 * set:
 <addset
 <addset
 <baseset [0]>,
 <baseset [1]>>,
 hg: parse error: can't use a list in this context
 (see hg help "revsets.x or y")
 [255]
 $ try '0,1,2'
 (list
-('symbol', '0')
+(symbol '0')
-('symbol', '1')
+(symbol '1')
-('symbol', '2'))
+(symbol '2'))
 hg: parse error: can't use a list in this context
 (see hg help "revsets.x or y")
 [255]
 test that chained `or` operations make balanced addsets
 $ try '0:1|1:2|2:3|3:4|4:5'
 (or
 (list
 (range
-('symbol', '0')
+(symbol '0')
-('symbol', '1'))
+(symbol '1'))
 (range
-('symbol', '1')
+(symbol '1')
-('symbol', '2'))
+(symbol '2'))
 (range
-('symbol', '2')
+(symbol '2')
-('symbol', '3'))
+(symbol '3'))
 (range
-('symbol', '3')
+(symbol '3')
-('symbol', '4'))
+(symbol '4'))
 (range
-('symbol', '4')
+(symbol '4')
-('symbol', '5'))))
+(symbol '5'))))
 * set:
 <addset
 <addset
 <spanset+ 0:2>,
 <spanset+ 1:3>>,
 no crash by empty group "()" while optimizing `or` operations
 $ try --optimize '0|()'
 (or
 (list
-('symbol', '0')
+(symbol '0')
 (group
 None)))
 * optimized:
 (or
 (list
-('symbol', '0')
+(symbol '0')
 None))
 hg: parse error: missing argument
 [255]
 test that chained `or` operations never eat up stack (issue4624)
 check that conversion to only works
 $ try --optimize '::3 - ::1'
 (minus
 (dagrangepre
-('symbol', '3'))
+(symbol '3'))
 (dagrangepre
-('symbol', '1')))
+(symbol '1')))
 * optimized:
 (func
-('symbol', 'only')
+(symbol 'only')
 (list
-('symbol', '3')
+(symbol '3')
-('symbol', '1')))
+(symbol '1')))
 * set:
 <baseset+ [3]>
 3
 $ try --optimize 'ancestors(1) - ancestors(3)'
 (minus
 (func
-('symbol', 'ancestors')
+(symbol 'ancestors')
-('symbol', '1'))
+(symbol '1'))
 (func
-('symbol', 'ancestors')
+(symbol 'ancestors')
-('symbol', '3')))
+(symbol '3')))
 * optimized:
 (func
-('symbol', 'only')
+(symbol 'only')
 (list
-('symbol', '1')
+(symbol '1')
-('symbol', '3')))
+(symbol '3')))
 * set:
 <baseset+ []>
 $ try --optimize 'not ::2 and ::6'
 (and
 (not
 (dagrangepre
-('symbol', '2')))
+(symbol '2')))
 (dagrangepre
-('symbol', '6')))
+(symbol '6')))
 * optimized:
 (func
-('symbol', 'only')
+(symbol 'only')
 (list
-('symbol', '6')
+(symbol '6')
-('symbol', '2')))
+(symbol '2')))
 * set:
 <baseset+ [3, 4, 5, 6]>
 3
 4
 5
 6
 $ try --optimize 'ancestors(6) and not ancestors(4)'
 (and
 (func
-('symbol', 'ancestors')
+(symbol 'ancestors')
-('symbol', '6'))
+(symbol '6'))
 (not
 (func
-('symbol', 'ancestors')
+(symbol 'ancestors')
-('symbol', '4'))))
+(symbol '4'))))
 * optimized:
 (func
-('symbol', 'only')
+(symbol 'only')
 (list
-('symbol', '6')
+(symbol '6')
-('symbol', '4')))
+(symbol '4')))
 * set:
 <baseset+ [3, 5, 6]>
 3
 5
 6
 no crash by empty group "()" while optimizing to "only()"
 $ try --optimize '::1 and ()'
 (and
 (dagrangepre
-('symbol', '1'))
+(symbol '1'))
 (group
 None))
 * optimized:
 (andsmally
 (func
-('symbol', 'ancestors')
+(symbol 'ancestors')
-('symbol', '1'))
+(symbol '1'))
 None)
 hg: parse error: missing argument
 [255]
 optimization to only() works only if ancestors() takes only one argument
 $ hg debugrevspec -p optimized 'ancestors(6) - ancestors(4, 1)'
 * optimized:
 (difference
 (func
-('symbol', 'ancestors')
+(symbol 'ancestors')
-('symbol', '6'))
+(symbol '6'))
 (func
-('symbol', 'ancestors')
+(symbol 'ancestors')
 (list
-('symbol', '4')
+(symbol '4')
-('symbol', '1'))))
+(symbol '1'))))
 0
 1
 3
 5
 6
 $ hg debugrevspec -p optimized 'ancestors(6, 1) - ancestors(4)'
 * optimized:
 (difference
 (func
-('symbol', 'ancestors')
+(symbol 'ancestors')
 (list
-('symbol', '6')
+(symbol '6')
-('symbol', '1')))
+(symbol '1')))
 (func
-('symbol', 'ancestors')
+(symbol 'ancestors')
-('symbol', '4')))
+(symbol '4')))
 5
 6
 optimization disabled if keyword arguments passed (because we're too lazy
 to support it)
 $ hg debugrevspec -p optimized 'ancestors(set=6) - ancestors(set=4)'
 * optimized:
 (difference
 (func
-('symbol', 'ancestors')
+(symbol 'ancestors')
 (keyvalue
-('symbol', 'set')
+(symbol 'set')
-('symbol', '6')))
+(symbol '6')))
 (func
-('symbol', 'ancestors')
+(symbol 'ancestors')
 (keyvalue
-('symbol', 'set')
+(symbol 'set')
-('symbol', '4'))))
+(symbol '4'))))
 3
 5
 6
 invalid function call should not be optimized to only()
 $ echo 'd($1) = reverse(sort($1, date))' >> .hg/hgrc
 $ echo 'rs(ARG1, ARG2) = reverse(sort(ARG1, ARG2))' >> .hg/hgrc
 $ echo 'rs4(ARG1, ARGA, ARGB, ARG2) = reverse(sort(ARG1, ARG2))' >> .hg/hgrc
 $ try m
-('symbol', 'm')
+(symbol 'm')
 * expanded:
 (func
-('symbol', 'merge')
+(symbol 'merge')
 None)
 * set:
 <filteredset
 <fullreposet+ 0:10>,
 <merge>>
 6
 $ HGPLAIN=1
 $ export HGPLAIN
 $ try m
-('symbol', 'm')
+(symbol 'm')
 abort: unknown revision 'm'!
 [255]
 $ HGPLAINEXCEPT=revsetalias
 $ export HGPLAINEXCEPT
 $ try m
-('symbol', 'm')
+(symbol 'm')
 * expanded:
 (func
-('symbol', 'merge')
+(symbol 'merge')
 None)
 * set:
 <filteredset
 <fullreposet+ 0:10>,
 <merge>>
 $ unset HGPLAIN
 $ unset HGPLAINEXCEPT
 $ try 'p2(.)'
 (func
-('symbol', 'p2')
+(symbol 'p2')
-('symbol', '.'))
+(symbol '.'))
 * expanded:
 (func
-('symbol', 'p1')
+(symbol 'p1')
-('symbol', '.'))
+(symbol '.'))
 * set:
 <baseset+ [8]>
 8
 $ HGPLAIN=1
 $ export HGPLAIN
 $ try 'p2(.)'
 (func
-('symbol', 'p2')
+(symbol 'p2')
-('symbol', '.'))
+(symbol '.'))
 * set:
 <baseset+ []>
 $ HGPLAINEXCEPT=revsetalias
 $ export HGPLAINEXCEPT
 $ try 'p2(.)'
 (func
-('symbol', 'p2')
+(symbol 'p2')
-('symbol', '.'))
+(symbol '.'))
 * expanded:
 (func
-('symbol', 'p1')
+(symbol 'p1')
-('symbol', '.'))
+(symbol '.'))
 * set:
 <baseset+ [8]>
 8
 $ unset HGPLAIN
 $ unset HGPLAINEXCEPT
 test alias recursion
 $ try sincem
-('symbol', 'sincem')
+(symbol 'sincem')
 * expanded:
 (func
-('symbol', 'descendants')
+(symbol 'descendants')
 (func
-('symbol', 'merge')
+(symbol 'merge')
 None))
 * set:
 <generatorset+>
 6
 7
 test infinite recursion
 $ echo 'recurse1 = recurse2' >> .hg/hgrc
 $ echo 'recurse2 = recurse1' >> .hg/hgrc
 $ try recurse1
-('symbol', 'recurse1')
+(symbol 'recurse1')
 hg: parse error: infinite expansion of revset alias "recurse1" detected
 [255]
 $ echo 'level1($1, $2) = $1 or $2' >> .hg/hgrc
 $ echo 'level2($1, $2) = level1($2, $1)' >> .hg/hgrc
 $ try "level2(level1(1, 2), 3)"
 (func
-('symbol', 'level2')
+(symbol 'level2')
 (list
 (func
-('symbol', 'level1')
+(symbol 'level1')
 (list
-('symbol', '1')
+(symbol '1')
-('symbol', '2')))
+(symbol '2')))
-('symbol', '3')))
+(symbol '3')))
 * expanded:
 (or
 (list
-('symbol', '3')
+(symbol '3')
 (or
 (list
-('symbol', '1')
+(symbol '1')
-('symbol', '2')))))
+(symbol '2')))))
 * set:
 <addset
 <baseset [3]>,
 <baseset [1, 2]>>
 3
 $ echo 'nested($1) = nested2($1)' >> .hg/hgrc
 $ echo 'nested2($1) = nested3($1)' >> .hg/hgrc
 $ echo 'nested3($1) = max($1)' >> .hg/hgrc
 $ try 'nested(2:5)'
 (func
-('symbol', 'nested')
+(symbol 'nested')
 (range
-('symbol', '2')
+(symbol '2')
-('symbol', '5')))
+(symbol '5')))
 * expanded:
 (func
-('symbol', 'max')
+(symbol 'max')
 (range
-('symbol', '2')
+(symbol '2')
-('symbol', '5')))
+(symbol '5')))
 * set:
 <baseset
 <max
 <fullreposet+ 0:10>,
 <spanset+ 2:6>>>
 test chained `or` operations are flattened at parsing phase
 $ echo 'chainedorops($1, $2, $3) = $1|$2|$3' >> .hg/hgrc
 $ try 'chainedorops(0:1, 1:2, 2:3)'
 (func
-('symbol', 'chainedorops')
+(symbol 'chainedorops')
 (list
 (range
-('symbol', '0')
+(symbol '0')
-('symbol', '1'))
+(symbol '1'))
 (range
-('symbol', '1')
+(symbol '1')
-('symbol', '2'))
+(symbol '2'))
 (range
-('symbol', '2')
+(symbol '2')
-('symbol', '3'))))
+(symbol '3'))))
 * expanded:
 (or
 (list
 (range
-('symbol', '0')
+(symbol '0')
-('symbol', '1'))
+(symbol '1'))
 (range
-('symbol', '1')
+(symbol '1')
-('symbol', '2'))
+(symbol '2'))
 (range
-('symbol', '2')
+(symbol '2')
-('symbol', '3'))))
+(symbol '3'))))
 * set:
 <addset
 <spanset+ 0:2>,
 <addset
 <spanset+ 1:3>,
 $ echo 'injectparamasstring = max("$1")' >> .hg/hgrc
 $ echo 'callinjection($1) = descendants(injectparamasstring)' >> .hg/hgrc
 $ try 'callinjection(2:5)'
 (func
-('symbol', 'callinjection')
+(symbol 'callinjection')
 (range
-('symbol', '2')
+(symbol '2')
-('symbol', '5')))
+(symbol '5')))
 * expanded:
 (func
-('symbol', 'descendants')
+(symbol 'descendants')
 (func
-('symbol', 'max')
+(symbol 'max')
-('string', '$1')))
+(string '$1')))
 abort: unknown revision '$1'!
 [255]
 test scope of alias expansion: 'universe' is expanded prior to 'shadowall(0)',
 but 'all()' should never be substituted to '0()'.
 $ echo 'universe = all()' >> .hg/hgrc
 $ echo 'shadowall(all) = all and universe' >> .hg/hgrc
 $ try 'shadowall(0)'
 (func
-('symbol', 'shadowall')
+(symbol 'shadowall')
-('symbol', '0'))
+(symbol '0'))
 * expanded:
 (and
-('symbol', '0')
+(symbol '0')
 (func
-('symbol', 'all')
+(symbol 'all')
 None))
 * set:
 <filteredset
 <baseset [0]>,
 <spanset+ 0:10>>
 test unknown reference:
 $ try "unknownref(0)" --config 'revsetalias.unknownref($1)=$1:$2'
 (func
-('symbol', 'unknownref')
+(symbol 'unknownref')
-('symbol', '0'))
+(symbol '0'))
 abort: bad definition of revset alias "unknownref": invalid symbol '$2'
 [255]
 $ hg debugrevspec --debug --config revsetalias.anotherbadone='branch(' "tip"
-('symbol', 'tip')
+(symbol 'tip')
 warning: bad definition of revset alias "anotherbadone": at 7: not a prefix: end
 * set:
 <baseset [9]>
 9
 $ try 'tip'
-('symbol', 'tip')
+(symbol 'tip')
 * set:
 <baseset [9]>
 9
 $ hg debugrevspec --debug --config revsetalias.'bad name'='tip' "tip"
-('symbol', 'tip')
+(symbol 'tip')
 warning: bad declaration of revset alias "bad name": at 4: invalid token
 * set:
 <baseset [9]>
 9
 $ echo 'strictreplacing($1, $10) = $10 or desc("$1")' >> .hg/hgrc
 $ try 'strictreplacing("foo", tip)'
 (func
-('symbol', 'strictreplacing')
+(symbol 'strictreplacing')
 (list
-('string', 'foo')
+(string 'foo')
-('symbol', 'tip')))
+(symbol 'tip')))
 * expanded:
 (or
 (list
-('symbol', 'tip')
+(symbol 'tip')
 (func
-('symbol', 'desc')
+(symbol 'desc')
-('string', '$1'))))
+(string '$1'))))
 * set:
 <addset
 <baseset [9]>,
 <filteredset
 <fullreposet+ 0:10>,
 <desc '$1'>>>
 9
 $ try 'd(2:5)'
 (func
-('symbol', 'd')
+(symbol 'd')
 (range
-('symbol', '2')
+(symbol '2')
-('symbol', '5')))
+(symbol '5')))
 * expanded:
 (func
-('symbol', 'reverse')
+(symbol 'reverse')
 (func
-('symbol', 'sort')
+(symbol 'sort')
 (list
 (range
-('symbol', '2')
+(symbol '2')
-('symbol', '5'))
+(symbol '5'))
-('symbol', 'date'))))
+(symbol 'date'))))
 * set:
 <baseset [4, 5, 3, 2]>
 4
 5
 3
 2
 $ try 'rs(2 or 3, date)'
 (func
-('symbol', 'rs')
+(symbol 'rs')
 (list
 (or
 (list
-('symbol', '2')
+(symbol '2')
-('symbol', '3')))
+(symbol '3')))
-('symbol', 'date')))
+(symbol 'date')))
 * expanded:
 (func
-('symbol', 'reverse')
+(symbol 'reverse')
 (func
-('symbol', 'sort')
+(symbol 'sort')
 (list
 (or
 (list
-('symbol', '2')
+(symbol '2')
-('symbol', '3')))
+(symbol '3')))
-('symbol', 'date'))))
+(symbol 'date'))))
 * set:
 <baseset [3, 2]>
 3
 2
 $ try 'rs()'
 (func
-('symbol', 'rs')
+(symbol 'rs')
 None)
 hg: parse error: invalid number of arguments: 0
 [255]
 $ try 'rs(2)'
 (func
-('symbol', 'rs')
+(symbol 'rs')
-('symbol', '2'))
+(symbol '2'))
 hg: parse error: invalid number of arguments: 1
 [255]
 $ try 'rs(2, data, 7)'
 (func
-('symbol', 'rs')
+(symbol 'rs')
 (list
-('symbol', '2')
+(symbol '2')
-('symbol', 'data')
+(symbol 'data')
-('symbol', '7')))
+(symbol '7')))
 hg: parse error: invalid number of arguments: 3
 [255]
 $ try 'rs4(2 or 3, x, x, date)'
 (func
-('symbol', 'rs4')
+(symbol 'rs4')
 (list
 (or
 (list
-('symbol', '2')
+(symbol '2')
-('symbol', '3')))
+(symbol '3')))
-('symbol', 'x')
+(symbol 'x')
-('symbol', 'x')
+(symbol 'x')
-('symbol', 'date')))
+(symbol 'date')))
 * expanded:
 (func
-('symbol', 'reverse')
+(symbol 'reverse')
 (func
-('symbol', 'sort')
+(symbol 'sort')
 (list
 (or
 (list
-('symbol', '2')
+(symbol '2')
-('symbol', '3')))
+(symbol '3')))
-('symbol', 'date'))))
+(symbol 'date'))))
 * set:
 <baseset [3, 2]>
 3
 2
 issue2549 - correct optimizations
 $ try 'limit(1 or 2 or 3, 2) and not 2'
 (and
 (func
-('symbol', 'limit')
+(symbol 'limit')
 (list
 (or
 (list
-('symbol', '1')
+(symbol '1')
-('symbol', '2')
+(symbol '2')
-('symbol', '3')))
+(symbol '3')))
-('symbol', '2')))
+(symbol '2')))
 (not
-('symbol', '2')))
+(symbol '2')))
 * set:
 <filteredset
 <baseset [1, 2]>,
 <not
 <baseset [2]>>>
 1
 $ try 'max(1 or 2) and not 2'
 (and
 (func
-('symbol', 'max')
+(symbol 'max')
 (or
 (list
-('symbol', '1')
+(symbol '1')
-('symbol', '2'))))
+(symbol '2'))))
 (not
-('symbol', '2')))
+(symbol '2')))
 * set:
 <filteredset
 <baseset
 <max
 <fullreposet+ 0:10>,
 <not
 <baseset [2]>>>
 $ try 'min(1 or 2) and not 1'
 (and
 (func
-('symbol', 'min')
+(symbol 'min')
 (or
 (list
-('symbol', '1')
+(symbol '1')
-('symbol', '2'))))
+(symbol '2'))))
 (not
-('symbol', '1')))
+(symbol '1')))
 * set:
 <filteredset
 <baseset
 <min
 <fullreposet+ 0:10>,
 <not
 <baseset [1]>>>
 $ try 'last(1 or 2, 1) and not 2'
 (and
 (func
-('symbol', 'last')
+(symbol 'last')
 (list
 (or
 (list
-('symbol', '1')
+(symbol '1')
-('symbol', '2')))
+(symbol '2')))
-('symbol', '1')))
+(symbol '1')))
 (not
-('symbol', '2')))
+(symbol '2')))
 * set:
 <filteredset
 <baseset [2]>,
 <not
 <baseset [2]>>>
 $ try "278 ## '5f5' ## 1ee ## 'ce5'"
 (_concat
 (_concat
 (_concat
-('symbol', '278')
+(symbol '278')
-('string', '5f5'))
+(string '5f5'))
-('symbol', '1ee'))
+(symbol '1ee'))
-('string', 'ce5'))
+(string 'ce5'))
 * concatenated:
-('string', '2785f51eece5')
+(string '2785f51eece5')
 * set:
 <baseset [0]>
 0
 $ echo 'cat4($1, $2, $3, $4) = $1 ## $2 ## $3 ## $4' >> .hg/hgrc
 $ try "cat4(278, '5f5', 1ee, 'ce5')"
 (func
-('symbol', 'cat4')
+(symbol 'cat4')
 (list
-('symbol', '278')
+(symbol '278')
-('string', '5f5')
+(string '5f5')
-('symbol', '1ee')
+(symbol '1ee')
-('string', 'ce5')))
+(string 'ce5')))
 * expanded:
 (_concat
 (_concat
 (_concat
-('symbol', '278')
+(symbol '278')
-('string', '5f5'))
+(string '5f5'))
-('symbol', '1ee'))
+(symbol '1ee'))
-('string', 'ce5'))
+(string 'ce5'))
 * concatenated:
-('string', '2785f51eece5')
+(string '2785f51eece5')
 * set:
 <baseset [0]>
 0
 (check concatenation in alias nesting)
 $ hg debugrevspec --verify -p analyzed -p optimized 'draft() & ::(((S1+D1+P5)-D3)+S2)'
 * analyzed:
 (and
 (func
-('symbol', 'draft')
+(symbol 'draft')
 None)
 (func
-('symbol', 'ancestors')
+(symbol 'ancestors')
 (or
 (list
 (and
 (or
 (list
-('symbol', 'S1')
+(symbol 'S1')
-('symbol', 'D1')
+(symbol 'D1')
-('symbol', 'P5')))
+(symbol 'P5')))
 (not
-('symbol', 'D3')))
+(symbol 'D3')))
-('symbol', 'S2')))))
+(symbol 'S2')))))
 * optimized:
 (func
-('symbol', '_phaseandancestors')
+(symbol '_phaseandancestors')
 (list
-('symbol', 'draft')
+(symbol 'draft')
 (or
 (list
 (difference
 (func
-('symbol', '_list')
+(symbol '_list')
-('string', 'S1\x00D1\x00P5'))
+(string 'S1\x00D1\x00P5'))
-('symbol', 'D3'))
+(symbol 'D3'))
-('symbol', 'S2')))))
+(symbol 'S2')))))
 $ hg debugrevspec --verify -p analyzed -p optimized 'secret() & ::9'
 * analyzed:
 (and
 (func
-('symbol', 'secret')
+(symbol 'secret')
 None)
 (func
-('symbol', 'ancestors')
+(symbol 'ancestors')
-('symbol', '9')))
+(symbol '9')))
 * optimized:
 (func
-('symbol', '_phaseandancestors')
+(symbol '_phaseandancestors')
 (list
-('symbol', 'secret')
+(symbol 'secret')
-('symbol', '9')))
+(symbol '9')))
 $ hg debugrevspec --verify -p analyzed -p optimized '7 & ( (not public()) & ::(tag()) )'
 * analyzed:
 (and
-('symbol', '7')
+(symbol '7')
 (and
 (not
 (func
-('symbol', 'public')
+(symbol 'public')
 None))
 (func
-('symbol', 'ancestors')
+(symbol 'ancestors')
 (func
-('symbol', 'tag')
+(symbol 'tag')
 None))))
 * optimized:
 (and
-('symbol', '7')
+(symbol '7')
 (func
-('symbol', '_phaseandancestors')
+(symbol '_phaseandancestors')
 (list
-('symbol', '_notpublic')
+(symbol '_notpublic')
 (func
-('symbol', 'tag')
+(symbol 'tag')
 None))))
 $ hg debugrevspec --verify -p optimized '(not public()) & ancestors(S1+D2+P5, 1)'
 * optimized:
 (and
 (func
-('symbol', '_notpublic')
+(symbol '_notpublic')
 None)
 (func
-('symbol', 'ancestors')
+(symbol 'ancestors')
 (list
 (func
-('symbol', '_list')
+(symbol '_list')
-('string', 'S1\x00D2\x00P5'))
+(string 'S1\x00D2\x00P5'))
-('symbol', '1'))))
+(symbol '1'))))
 $ hg debugrevspec --verify -p optimized '(not public()) & ancestors(S1+D2+P5, depth=1)'
 * optimized:
 (and
 (func
-('symbol', '_notpublic')
+(symbol '_notpublic')
 None)
 (func
-('symbol', 'ancestors')
+(symbol 'ancestors')
 (list
 (func
-('symbol', '_list')
+(symbol '_list')
-('string', 'S1\x00D2\x00P5'))
+(string 'S1\x00D2\x00P5'))
 (keyvalue
-('symbol', 'depth')
+(symbol 'depth')
-('symbol', '1')))))
+(symbol '1')))))

changeset 34073	7bbc4e113e5f
parent 34065	c6c8a52e28c9
child 34126	af13097b44dd