$ fileset() {

  >   hg debugfileset --all-files "$@"

  > }

  $ hg init repo

  $ cd repo

  $ echo a > a1

  $ echo a > a2

  $ echo b > b1

  $ echo b > b2

  $ hg ci -Am addfiles

  adding a1

  adding a2

  adding b1

  adding b2

Test operators and basic patterns

  $ fileset -v a1

  (symbol 'a1')

  * matcher:

  <patternmatcher patterns='a1$'>

  a1

  $ fileset -v 'a*'

  (symbol 'a*')

  * matcher:

  <patternmatcher patterns='a[^/]*$'>

  a1

  a2

  $ fileset -v '"re:a\d"'

  (string 're:a\\d')

  * matcher:

  <patternmatcher patterns='a\\d'>

  a1

  a2

  $ fileset -v '!re:"a\d"'

  (not

    (kindpat

      (symbol 're')

      (string 'a\\d')))

  * matcher:

  <predicatenmatcher

    pred=<not

      <patternmatcher patterns='a\\d'>>>

  b1

  b2

  $ fileset -v 'path:a1 or glob:b?'

  (or

    (kindpat

      (symbol 'path')

      (symbol 'a1'))

    (kindpat

      (symbol 'glob')

      (symbol 'b?')))

  * matcher:

  <patternmatcher patterns='a1(?:/|$)|b.$'>

  a1

  b1

  b2

  $ fileset -v --no-show-matcher 'a1 or a2'

  (or

    (symbol 'a1')

    (symbol 'a2'))

  a1

  a2

  $ fileset 'a1 | a2'

  a1

  a2

  $ fileset 'a* and "*1"'

  a1

  $ fileset 'a* & "*1"'

  a1

  $ fileset 'not (r"a*")'

  b1

  b2

  $ fileset '! ("a*")'

  b1

  b2

  $ fileset 'a* - a1'

  a2

  $ fileset 'a_b'

  $ fileset '"\xy"'

  hg: parse error: invalid \x escape* (glob)

  [10]

Test invalid syntax

  $ fileset -v '"added"()'

  (func

    (string 'added')

    None)

  hg: parse error: not a symbol

  [10]

  $ fileset -v '()()'

  (func

    (group

      None)

    None)

  hg: parse error: not a symbol

  [10]

  $ fileset -v -- '-x'

  (negate

    (symbol 'x'))

  hg: parse error: can't use negate operator in this context

  [10]

  $ fileset -v -- '-()'

  (negate

    (group

      None))

  hg: parse error: can't use negate operator in this context

  [10]

  $ fileset -p parsed 'a, b, c'

  * parsed:

  (list

    (symbol 'a')

    (symbol 'b')

    (symbol 'c'))

  hg: parse error: can't use a list in this context

  (see 'hg help "filesets.x or y"')

  [10]

  $ fileset '"path":.'

  hg: parse error: not a symbol

  [10]

  $ fileset 'path:foo bar'

  hg: parse error at 9: invalid token

  [10]

  $ fileset 'foo:bar:baz'

  hg: parse error: not a symbol

  [10]

  $ fileset 'foo:bar()'

  hg: parse error: pattern must be a string

  [10]

  $ fileset 'foo:bar'

  hg: parse error: invalid pattern kind: foo

  [10]

Show parsed tree at stages:

  $ fileset -p unknown a

  abort: invalid stage name: unknown

  [255]

  $ fileset -p parsed 'path:a1 or glob:b?'

  * parsed:

  (or

    (kindpat

      (symbol 'path')

      (symbol 'a1'))

    (kindpat

      (symbol 'glob')

      (symbol 'b?')))

  a1

  b1

  b2

  $ fileset -p all -s 'a1 or a2 or (grep("b") & clean())'

  * parsed:

  (or

    (symbol 'a1')

    (symbol 'a2')

    (group

      (and

        (func

          (symbol 'grep')

          (string 'b'))

        (func

          (symbol 'clean')

          None))))

  * analyzed:

  (or

    (symbol 'a1')

    (symbol 'a2')

    (and

      (func

        (symbol 'grep')

        (string 'b'))

      (withstatus

        (func

          (symbol 'clean')

          None)

        (string 'clean'))))

  * optimized:

  (or

    (patterns

      (symbol 'a1')

      (symbol 'a2'))

    (and

      (withstatus

        (func

          (symbol 'clean')

          None)

        (string 'clean'))

      (func

        (symbol 'grep')

        (string 'b'))))

  * matcher:

  <unionmatcher matchers=[

    <patternmatcher patterns='a1$|a2$'>,

    <intersectionmatcher

      m1=<predicatenmatcher pred=clean>,

      m2=<predicatenmatcher pred=grep('b')>>]>

  a1

  a2

  b1

  b2

Union of basic patterns:

  $ fileset -p optimized -s -r. 'a1 or a2 or path:b1'

  * optimized:

  (patterns

    (symbol 'a1')

    (symbol 'a2')

    (kindpat

      (symbol 'path')

      (symbol 'b1')))

  * matcher:

  <patternmatcher patterns='a1$|a2$|b1(?:/|$)'>

  a1

  a2

  b1

OR expression should be reordered by weight:

  $ fileset -p optimized -s -r. 'grep("a") or a1 or grep("b") or b2'

  * optimized:

  (or

    (patterns

      (symbol 'a1')

      (symbol 'b2'))

    (func

      (symbol 'grep')

      (string 'a'))

    (func

      (symbol 'grep')

      (string 'b')))

  * matcher:

  <unionmatcher matchers=[

    <patternmatcher patterns='a1$|b2$'>,

    <predicatenmatcher pred=grep('a')>,

    <predicatenmatcher pred=grep('b')>]>

  a1

  a2

  b1

  b2

Use differencematcher for 'x and not y':

  $ fileset -p optimized -s 'a* and not a1'

  * optimized:

  (minus

    (symbol 'a*')

    (symbol 'a1'))

  * matcher:

  <differencematcher

    m1=<patternmatcher patterns='a[^/]*$'>,

    m2=<patternmatcher patterns='a1$'>>

  a2

  $ fileset -p optimized -s '!binary() and a*'

  * optimized:

  (minus

    (symbol 'a*')

    (func

      (symbol 'binary')

      None))

  * matcher:

  <differencematcher

    m1=<patternmatcher patterns='a[^/]*$'>,

    m2=<predicatenmatcher pred=binary>>

  a1

  a2

'x - y' is rewritten to 'x and not y' first so the operands can be reordered:

  $ fileset -p analyzed -p optimized -s 'a* - a1'

  * analyzed:

  (and

    (symbol 'a*')

    (not

      (symbol 'a1')))

  * optimized:

  (minus

    (symbol 'a*')

    (symbol 'a1'))

  * matcher:

  <differencematcher

    m1=<patternmatcher patterns='a[^/]*$'>,

    m2=<patternmatcher patterns='a1$'>>

  a2

  $ fileset -p analyzed -p optimized -s 'binary() - a*'

  * analyzed:

  (and

    (func

      (symbol 'binary')

      None)

    (not

      (symbol 'a*')))

  * optimized:

  (and

    (not

      (symbol 'a*'))

    (func

      (symbol 'binary')

      None))

  * matcher:

  <intersectionmatcher

    m1=<predicatenmatcher

      pred=<not

        <patternmatcher patterns='a[^/]*$'>>>,

    m2=<predicatenmatcher pred=binary>>

Test files status

  $ rm a1

  $ hg rm a2

  $ echo b >> b2

  $ hg cp b1 c1

  $ echo c > c2

  $ echo c > c3

  $ cat > .hgignore <<EOF

  > \.hgignore

  > 2$

  > EOF

  $ fileset 'modified()'

  b2

  $ fileset 'added()'

  c1

  $ fileset 'removed()'

  a2

  $ fileset 'deleted()'

  a1

  $ fileset 'missing()'

  a1

  $ fileset 'unknown()'

  c3

  $ fileset 'ignored()'

  .hgignore

  c2

  $ fileset 'hgignore()'

  .hgignore

  a2

  b2

  c2

  $ fileset 'clean()'

  b1

  $ fileset 'copied()'

  c1

Test files status in different revisions

  $ hg status -m

  M b2

  $ fileset -r0 'revs("wdir()", modified())' --traceback

  b2

  $ hg status -a

  A c1

  $ fileset -r0 'revs("wdir()", added())'

  c1

  $ hg status --change 0 -a

  A a1

  A a2

  A b1

  A b2

  $ hg status -mru

  M b2

  R a2

  ? c3

  $ fileset -r0 'added() and revs("wdir()", modified() or removed() or unknown())'

  a2

  b2

  $ fileset -r0 'added() or revs("wdir()", added())'

  a1

  a2

  b1

  b2

  c1

Test insertion of status hints

  $ fileset -p optimized 'added()'

  * optimized:

  (withstatus

    (func

      (symbol 'added')

      None)

    (string 'added'))

  c1

  $ fileset -p optimized 'a* & removed()'

  * optimized:

  (and

    (symbol 'a*')

    (withstatus

      (func

        (symbol 'removed')

        None)

      (string 'removed')))

  a2

  $ fileset -p optimized 'a* - removed()'

  * optimized:

  (minus

    (symbol 'a*')

    (withstatus

      (func

        (symbol 'removed')

        None)

      (string 'removed')))

  a1

  $ fileset -p analyzed -p optimized '(added() + removed()) - a*'