*** Running test-arglist

===== CASE: -n -c json write () =====


  json write ()
             ^
[ -c flag ]:1: Empty arg list not allowed

===== CASE: -n -c json write (42, indent=1) =====


(command.Simple
  blame_tok:<Lit_Chars json>
  more_env:[]
  words:[(w <Lit_Chars json>) (w <Lit_Chars write>)]
  typed_args:(ArgList
    left:<Op_LParen "(">
    pos_args:[(Const Expr_DecInt _)]
    named_args:[(NamedArg name:<Expr_Name indent> value:(Const Expr_DecInt _))]
    right:<Op_RParen ")">
  )
  is_last_cmd:F
)

===== CASE: -n -c json write (42; indent=2) =====


(command.Simple
  blame_tok:<Lit_Chars json>
  more_env:[]
  words:[(w <Lit_Chars json>) (w <Lit_Chars write>)]
  typed_args:(ArgList
    left:<Op_LParen "(">
    pos_args:[(Const Expr_DecInt _)]
    semi_tok:<Op_Semi ";">
    named_args:[(NamedArg name:<Expr_Name indent> value:(Const Expr_DecInt _))]
    right:<Op_RParen ")">
  )
  is_last_cmd:F
)

===== CASE: -n -c = toJson(42, indent=1) =====


(command.Expr
  keyword:<Lit_Equals "=">
  e:(expr.FuncCall
    func:(Var toJson)
    args:(ArgList
      left:<Op_LParen "(">
      pos_args:[(Const Expr_DecInt _)]
      named_args:[
        (NamedArg name:<Expr_Name indent> value:(Const Expr_DecInt _))
      ]
      right:<Op_RParen ")">
    )
  )
)

===== CASE: -n -c = toJson(42; indent=2) =====


(command.Expr
  keyword:<Lit_Equals "=">
  e:(expr.FuncCall
    func:(Var toJson)
    args:(ArgList
      left:<Op_LParen "(">
      pos_args:[(Const Expr_DecInt _)]
      semi_tok:<Op_Semi ";">
      named_args:[
        (NamedArg name:<Expr_Name indent> value:(Const Expr_DecInt _))
      ]
      right:<Op_RParen ")">
    )
  )
)

===== CASE: -n -c p (; n=true) =====


(command.Simple
  blame_tok:<Lit_Chars p>
  more_env:[]
  words:[(w <Lit_Chars p>)]
  typed_args:(ArgList
    left:<Op_LParen "(">
    pos_args:[]
    semi_tok:<Op_Semi ";">
    named_args:[(NamedArg name:<Expr_Name n> value:(Const Expr_True _))]
    right:<Op_RParen ")">
  )
  is_last_cmd:F
)

===== CASE: -n -c = f(; n=true) =====


(command.Expr
  keyword:<Lit_Equals "=">
  e:(expr.FuncCall
    func:(Var f)
    args:(ArgList
      left:<Op_LParen "(">
      pos_args:[]
      semi_tok:<Op_Semi ";">
      named_args:[(NamedArg name:<Expr_Name n> value:(Const Expr_True _))]
      right:<Op_RParen ")">
    )
  )
)

===== CASE: -n -c p (;) =====


(command.Simple
  blame_tok:<Lit_Chars p>
  more_env:[]
  words:[(w <Lit_Chars p>)]
  typed_args:(ArgList
    left:<Op_LParen "(">
    pos_args:[]
    semi_tok:<Op_Semi ";">
    named_args:[]
    right:<Op_RParen ")">
  )
  is_last_cmd:F
)

===== CASE: -n -c = f(;) =====


(command.Expr
  keyword:<Lit_Equals "=">
  e:(expr.FuncCall
    func:(Var f)
    args:(ArgList
      left:<Op_LParen "(">
      pos_args:[]
      semi_tok:<Op_Semi ";">
      named_args:[]
      right:<Op_RParen ")">
    )
  )
)

===== CASE: -n -c p (42;) =====


(command.Simple
  blame_tok:<Lit_Chars p>
  more_env:[]
  words:[(w <Lit_Chars p>)]
  typed_args:(ArgList
    left:<Op_LParen "(">
    pos_args:[(Const Expr_DecInt _)]
    semi_tok:<Op_Semi ";">
    named_args:[]
    right:<Op_RParen ")">
  )
  is_last_cmd:F
)

===== CASE: -n -c = f(42;) =====


(command.Expr
  keyword:<Lit_Equals "=">
  e:(expr.FuncCall
    func:(Var f)
    args:(ArgList
      left:<Op_LParen "(">
      pos_args:[(Const Expr_DecInt _)]
      semi_tok:<Op_Semi ";">
      named_args:[]
      right:<Op_RParen ")">
    )
  )
)

===== CASE: -n -c = f(42; n=true; block) =====


  = f(42; n=true; block)
                ^
[ -c flag ]:1: Syntax error in expression (near Id.Op_Semi)

===== CASE: -n -c = f(42; ; block) =====


  = f(42; ; block)
          ^
[ -c flag ]:1: Syntax error in expression (near Id.Op_Semi)

===== CASE: -n -c p (42; n=true; block) =====


(command.Simple
  blame_tok:<Lit_Chars p>
  more_env:[]
  words:[(w <Lit_Chars p>)]
  typed_args:(ArgList
    left:<Op_LParen "(">
    pos_args:[(Const Expr_DecInt _)]
    semi_tok:<Op_Semi ";">
    named_args:[(NamedArg name:<Expr_Name n> value:(Const Expr_True _))]
    semi_tok2:<Op_Semi ";">
    block_expr:(Var block)
    right:<Op_RParen ")">
  )
  is_last_cmd:F
)

===== CASE: -n -c p (42; ; block) =====


(command.Simple
  blame_tok:<Lit_Chars p>
  more_env:[]
  words:[(w <Lit_Chars p>)]
  typed_args:(ArgList
    left:<Op_LParen "(">
    pos_args:[(Const Expr_DecInt _)]
    semi_tok:<Op_Semi ";">
    named_args:[]
    semi_tok2:<Op_Semi ";">
    block_expr:(Var block)
    right:<Op_RParen ")">
  )
  is_last_cmd:F
)

===== CASE: -n -c p (42; n=42; bad=3) =====


  p (42; n=42; bad=3)
               ^~~
[ -c flag ]:1: Invalid block expression argument

===== CASE: -n -c p (42; n=42; ...bad) =====


  p (42; n=42; ...bad)
               ^~~
[ -c flag ]:1: Invalid block expression argument

===== CASE: -n -c = f(; 42) =====


  = f(; 42)
        ^~
[ -c flag ]:1: Positional arg can't appear in group of named args

===== CASE: -n -c = f(; name) =====


  = f(; name)
        ^~~~
[ -c flag ]:1: Positional arg can't appear in group of named args

===== CASE: -n -c = f(; x for x in y) =====


  = f(; x for x in y)
        ^
[ -c flag ]:1: Positional arg can't appear in group of named args
OK  test-arglist
*** Running test-blocks

===== CASE: -n -c >out { echo hi } =====


  >out { echo hi }
       ^
[ -c flag ]:1: Unexpected typed args

===== CASE: -n -c a=1 b=2 { echo hi } =====


  a=1 b=2 { echo hi }
          ^
[ -c flag ]:1: Unexpected typed args

===== CASE: -n -c break { echo hi } =====


  break { echo hi }
        ^
[ -c flag ]:1: Unexpected typed args

===== CASE: -n -c cd / { echo hi } cd / =====


  cd / { echo hi } cd /
                   ^~
[ -c flag ]:1: Invalid word while parsing command line (Id.Word_Compound)
OK  test-blocks
*** Running test-bug-1118

===== CASE: -n -c 
  var snippets = [{status: 42}]
  for snippet in (snippets) {
    if (snippet["status"] === 0) {
      echo hi
    }

    # The $ causes a weird error
    if ($snippet["status"] === 0) {
      echo hi
    }
  }
   =====


      if ($snippet["status"] === 0) {
          ^~~~~~~~
[ -c flag ]:9: In expressions, remove $ and use `snippet`, or sometimes "$snippet"

===== CASE: -n -c 
  var content = [ 1, 2, 4 ]
  var count = 0

  # The $ causes a weird error
  while (count < $len(content)) {
    setvar count += 1
  }
   =====


    while (count < $len(content)) {
                   ^~~~
[ -c flag ]:6: In expressions, remove $ and use `len`, or sometimes "$len"
OK  test-bug-1118
*** Running test-bug-1826

===== CASE: -n -c echo b'\xff' =====


  echo b'\xff'
         ^
[ -c flag ]:1: Invalid char escape in C-style string literal (OILS-ERR-11)

===== CASE: -n -c var s = b'\xff' =====


  var s = b'\xff'
            ^
[ -c flag ]:1: Invalid char escape in C-style string literal (OILS-ERR-11)
[echo b'\]

===== CASE: -n -c echo b'\ =====


  echo b'\
         ^
[ -c flag ]:1: Invalid char escape in C-style string literal (OILS-ERR-11)
[var s = b'\]

===== CASE: -n -c var s = b'\ =====


  var s = b'\
            ^
[ -c flag ]:1: Invalid char escape in C-style string literal (OILS-ERR-11)
[var s = $'\]

===== CASE: -n -c var s = $'\ =====


  var s = $'\
            ^
[ -c flag ]:1: Invalid char escape in C-style string literal (OILS-ERR-11)
OK  test-bug-1826
*** Running test-bug-1850

===== CASE: -n -c pp test_ (42); pp line (43) =====


(command.CommandList
  children:[
    (command.Sentence
      child:(command.Simple
        blame_tok:<Lit_Chars pp>
        more_env:[]
        words:[(w <Lit_Chars pp>) (w <Lit_Chars test_>)]
        typed_args:(ArgList
          left:<Op_LParen "(">
          pos_args:[(Const Expr_DecInt _)]
          named_args:[]
          right:<Op_RParen ")">
        )
        is_last_cmd:F
      )
      terminator:<Op_Semi ";">
    )
    (command.Simple
      blame_tok:<Lit_Chars pp>
      more_env:[]
      words:[(w <Lit_Chars pp>) (w <Lit_Chars line>)]
      typed_args:(ArgList
        left:<Op_LParen "(">
        pos_args:[(Const Expr_DecInt _)]
        named_args:[]
        right:<Op_RParen ")">
      )
      is_last_cmd:F
    )
  ]
)

===== CASE: -n -c pp test_ (42) extra =====


  pp test_ (42) extra
                ^~~~~
[ -c flag ]:1: Invalid word while parsing command line (Id.Word_Compound)

===== CASE: -n -c pp test_ (42), echo =====


  pp test_ (42), echo
               ^
[ -c flag ]:1: Invalid word while parsing command line (Id.Word_Compound)

===== CASE: -n -c pp test_ @(echo), echo =====


  pp test_ @(echo), echo
                  ^
[ -c flag ]:1: Unexpected token after @()

===== CASE: -n -c pp test_ (42) =====


(command.Simple
  blame_tok:<Lit_Chars pp>
  more_env:[]
  words:[(w <Lit_Chars pp>) (w <Lit_Chars test_>)]
  typed_args:(ArgList
    left:<Op_LParen "(">
    pos_args:[(Const Expr_DecInt _)]
    named_args:[]
    right:<Op_RParen ")">
  )
  is_last_cmd:F
)

===== CASE: -n -c pp test_ (42)  =====


(command.Simple
  blame_tok:<Lit_Chars pp>
  more_env:[]
  words:[(w <Lit_Chars pp>) (w <Lit_Chars test_>)]
  typed_args:(ArgList
    left:<Op_LParen "(">
    pos_args:[(Const Expr_DecInt _)]
    named_args:[]
    right:<Op_RParen ")">
  )
  is_last_cmd:F
)

===== CASE: -n -c pp test_ (42); =====


(command.Sentence
  child:(command.Simple
    blame_tok:<Lit_Chars pp>
    more_env:[]
    words:[(w <Lit_Chars pp>) (w <Lit_Chars test_>)]
    typed_args:(ArgList
      left:<Op_LParen "(">
      pos_args:[(Const Expr_DecInt _)]
      named_args:[]
      right:<Op_RParen ")">
    )
    is_last_cmd:F
  )
  terminator:<Op_Semi ";">
)

===== CASE: -n -c pp test_ (42) { echo hi } =====


(command.Simple
  blame_tok:<Lit_Chars pp>
  more_env:[]
  words:[(w <Lit_Chars pp>) (w <Lit_Chars test_>)]
  typed_args:(ArgList
    left:<Op_LParen "(">
    pos_args:[(Const Expr_DecInt _)]
    named_args:[]
    right:<Op_RParen ")">
  )
  block:(LiteralBlock
    brace_group:(BraceGroup
      left:<Lit_LBrace "{">
      children:[(C (w <Lit_Chars echo>) (w <Lit_Chars hi>))]
      right:<Lit_RBrace "}">
    )
    lines:[
      (SourceLine
        line_num:1
        content:"pp test_ (42) { echo hi }"
        src:(source.CFlag)
      )
    ]
  )
  is_last_cmd:F
)

===== CASE: -n -c pp test_ (42), pp line (43) =====


  pp test_ (42), pp line (43)
               ^
[ -c flag ]:1: Invalid word while parsing command line (Id.Word_Compound)
OK  test-bug-1850
*** Running test-bug-1850-more

===== CASE: -n -c assert (42)extra =====


  assert (42)extra
             ^~~~~
[ -c flag ]:1: Invalid word while parsing command line (Id.Word_Compound)

===== CASE: -n -c assert (42) extra =====


  assert (42) extra
              ^~~~~
[ -c flag ]:1: Invalid word while parsing command line (Id.Word_Compound)

===== CASE: -n -c assert [42]extra =====


  assert [42]extra
             ^~~~~
[ -c flag ]:1: Invalid word while parsing command line (Id.Word_Compound)

===== CASE: -n -c assert [42] extra =====


  assert [42] extra
              ^~~~~
[ -c flag ]:1: Invalid word while parsing command line (Id.Word_Compound)
OK  test-bug-1850-more
*** Running test-bug_1825_backslashes

===== CASE: -n -c echo $'trailing\
' =====


(C
  (w <Lit_Chars echo>)
  (w
    (SingleQuoted
      left:<Left_DollarSingleQuote "$'">
      sval:"trailing\\\n"
      right:<Right_SingleQuote "'">
    )
  )
)

===== CASE: -n -c echo $'trailing\\
' =====


(C
  (w <Lit_Chars echo>)
  (w
    (SingleQuoted
      left:<Left_DollarSingleQuote "$'">
      sval:"trailing\\\n"
      right:<Right_SingleQuote "'">
    )
  )
)

===== CASE: -n -c echo $'trailing\
' =====


  echo $'trailing\
                 ^~
[ -c flag ]:1: Invalid char escape in C-style string literal (OILS-ERR-11)

===== CASE: -n -c setvar x = $'trailing\
' =====


  setvar x = $'trailing\
                       ^~
[ -c flag ]:1: Invalid char escape in C-style string literal (OILS-ERR-11)
OK  test-bug_1825_backslashes
*** Running test-command-simple-more

===== CASE: -n -c foo=1 =====


(command.ShAssignment
  left:<Lit_VarLike "foo=">
  pairs:[
    (AssignPair
      left:...0x7f7a5fc40668
      lhs:(sh_lhs.Name left:...0x7f7a5fc40668 name:foo)
      op:assign_op.Equal
      rhs:(w <Lit_Chars 1>)
    )
  ]
)

===== CASE: -n -c foo=1 >out (42) =====


  foo=1 >out (42)
             ^
[ -c flag ]:1: Unexpected typed args

===== CASE: -n -c foo=1 (42) =====


  foo=1 (42)
        ^
[ -c flag ]:1: Unexpected typed args

===== CASE: -n -c foo=1 cmd (42) =====


(command.Simple
  blame_tok:<Lit_Chars cmd>
  more_env:[(EnvPair left:<Lit_VarLike "foo="> name:foo val:(w <Lit_Chars 1>))]
  words:[(w <Lit_Chars cmd>)]
  typed_args:(ArgList
    left:<Op_LParen "(">
    pos_args:[(Const Expr_DecInt _)]
    named_args:[]
    right:<Op_RParen ")">
  )
  is_last_cmd:F
)

===== CASE: -n -c foo=1 cmd >out (42) =====


(command.Redirect
  child:(command.Simple
    blame_tok:<Lit_Chars cmd>
    more_env:[
      (EnvPair left:<Lit_VarLike "foo="> name:foo val:(w <Lit_Chars 1>))
    ]
    words:[(w <Lit_Chars cmd>)]
    typed_args:(ArgList
      left:<Op_LParen "(">
      pos_args:[(Const Expr_DecInt _)]
      named_args:[]
      right:<Op_RParen ")">
    )
    is_last_cmd:F
  )
  redirects:[
    (Redir op:<Redir_Great ">"> loc:(redir_loc.Fd fd:1) arg:(w <Lit_Chars out>))
  ]
)
OK  test-command-simple-more
*** Running test-destructure

===== CASE: -n -c 
  func f() {
    const x, y = 3, 4

    #setvar x = 5

    setvar y = 6
  } =====


      const x, y = 3, 4
      ^~~~~
[ -c flag ]:3: const can't be inside proc or func.  Use var instead.

===== CASE: -n -c 
  func f() {
    var x, y = 3, 4

    var y = 6
  } =====


      var y = 6
          ^
[ -c flag ]:5: 'y' was already declared

===== CASE: -n -c 
  func f() {
    var x, y = 3, 4

    const y = 6
  } =====


      const y = 6
      ^~~~~
[ -c flag ]:5: const can't be inside proc or func.  Use var instead.
OK  test-destructure
*** Running test-eggex

===== CASE: -n -c = /%start dot %end \n \u{ff}/ =====


(command.Expr
  keyword:<Lit_Equals "=">
  e:(Eggex
    left:<Arith_Slash />
    regex:(re.Seq
      children:[
        (re.Primitive blame_tok:<Expr_Symbol "%start"> id:Eggex_Start)
        (re.Primitive blame_tok:<Expr_Name dot> id:Eggex_Dot)
        (re.Primitive blame_tok:<Expr_Symbol "%end"> id:Eggex_End)
        (re.LiteralChars blame_tok:<Char_OneChar "\\n"> s:"\n")
        (re.LiteralChars blame_tok:<Char_UBraced "\\u{ff}"> s:"ÿ")
      ]
    )
    flags:[]
    canonical_flags:""
  )
)

===== CASE: -n -c = /%star dot %end \n/ =====


  = /%star dot %end \n/
     ^~~~~
[ -c flag ]:1: Unexpected token '%star' in regex

===== CASE: -n -c = /%start do %end \n/ =====


  = /%start do %end \n/
            ^~
[ -c flag ]:1: 'do' isn't a character class

===== CASE: -n -c = /%start dot %end \z/ =====


  = /%start dot %end \z/
                     ^
[ -c flag ]:1: Unexpected token in expression mode

===== CASE: -n -c = /%start dot %end \n \u{}/ =====


  = /%start dot %end \n \u{}/
                        ^
[ -c flag ]:1: Unexpected token in expression mode

===== CASE: -n -c = /['a'-'z']/ =====


(command.Expr
  keyword:<Lit_Equals "=">
  e:(Eggex
    left:<Arith_Slash />
    regex:(re.CharClassLiteral
      negated:F
      terms:[
        (CharRange
          start:(CharCode blame_tok:<Left_SingleQuote "'"> i:97 u_braced:F)
          end:(CharCode blame_tok:<Left_SingleQuote "'"> i:122 u_braced:F)
        )
      ]
    )
    flags:[]
    canonical_flags:""
  )
)

===== CASE: -n -c = /['a'-'']/ =====


  = /['a'-'']/
          ^
[ -c flag ]:1: Quoted range char can't be empty

===== CASE: -n -c = /['a'-'zz']/ =====


  = /['a'-'zz']/
          ^
[ -c flag ]:1: Range start/end shouldn't have more than one character

===== CASE: -n -c = /dot{N *} / =====


  = /dot{N *} /
         ^
[ -c flag ]:1: Perl-style repetition isn't implemented with libc

===== CASE: -n -c = /dot{zzz *} / =====


  = /dot{zzz *} /
         ^~~
[ -c flag ]:1: Perl-style repetition isn't implemented with libc

===== CASE: -n -c = /dot{*} / =====


  = /dot{*} /
         ^
[ -c flag ]:1: Perl-style repetition isn't implemented with libc
OK  test-eggex
*** Running test-eggex-capture

===== CASE: -n -c = / d+ / =====


(command.Expr
  keyword:<Lit_Equals "=">
  e:(Eggex
    left:<Arith_Slash />
    regex:(re.Repeat child:(PerlClass name:d) op:<Arith_Plus "+">)
    flags:[]
    canonical_flags:""
  )
)

===== CASE: -n -c = / < capture d+ as date > / =====


(command.Expr
  keyword:<Lit_Equals "=">
  e:(Eggex
    left:<Arith_Slash />
    regex:(re.Capture
      child:(re.Repeat child:(PerlClass name:d) op:<Arith_Plus "+">)
      name:<Expr_Name date>
    )
    flags:[]
    canonical_flags:""
  )
)

===== CASE: -n -c = / < capture d+ as date: Int > / =====


(command.Expr
  keyword:<Lit_Equals "=">
  e:(Eggex
    left:<Arith_Slash />
    regex:(re.Capture
      child:(re.Repeat child:(PerlClass name:d) op:<Arith_Plus "+">)
      name:<Expr_Name date>
      func_name:<Expr_Name Int>
    )
    flags:[]
    canonical_flags:""
  )
)

===== CASE: -n -c var capture = 42 =====


  var capture = 42
      ^~~~~~~
[ -c flag ]:1: Syntax error in expression (near Id.Expr_Capture)

===== CASE: -n -c var as = 42 =====


  var as = 42
      ^~
[ -c flag ]:1: Syntax error in expression (near Id.Expr_As)
OK  test-eggex-capture
*** Running test-eggex-flags

===== CASE: -n -c = / d+ ; reg_icase / =====


(command.Expr
  keyword:<Lit_Equals "=">
  e:(Eggex
    left:<Arith_Slash />
    regex:(re.Repeat child:(PerlClass name:d) op:<Arith_Plus "+">)
    flags:[(EggexFlag negated:F flag:<Expr_Name reg_icase>)]
    canonical_flags:i
  )
)

===== CASE: -n -c = / d+ ; i / =====


(command.Expr
  keyword:<Lit_Equals "=">
  e:(Eggex
    left:<Arith_Slash />
    regex:(re.Repeat child:(PerlClass name:d) op:<Arith_Plus "+">)
    flags:[(EggexFlag negated:F flag:<Expr_Name i>)]
    canonical_flags:i
  )
)

===== CASE: -n -c = / d+ ; !i / =====


  = / d+ ; !i /
            ^
[ -c flag ]:1: Flag can't be negated

===== CASE: -n -c = / d+ ; reg_oops / =====


  = / d+ ; reg_oops /
           ^~~~~~~~
[ -c flag ]:1: Invalid regex flag 'reg_oops'

===== CASE: -n -c = / d+ ; !i; PCRE / =====


(command.Expr
  keyword:<Lit_Equals "=">
  e:(Eggex
    left:<Arith_Slash />
    regex:(re.Repeat child:(PerlClass name:d) op:<Arith_Plus "+">)
    flags:[(EggexFlag negated:T flag:<Expr_Name i>)]
    trans_pref:<Expr_Name PCRE>
  )
)

===== CASE: -n -c = / d+ ; reg_oops; PCRE / =====


(command.Expr
  keyword:<Lit_Equals "=">
  e:(Eggex
    left:<Arith_Slash />
    regex:(re.Repeat child:(PerlClass name:d) op:<Arith_Plus "+">)
    flags:[(EggexFlag negated:F flag:<Expr_Name reg_oops>)]
    trans_pref:<Expr_Name PCRE>
  )
)

===== CASE: -n -c = / d+ ; i reg_newline ; ERE / =====


(command.Expr
  keyword:<Lit_Equals "=">
  e:(Eggex
    left:<Arith_Slash />
    regex:(re.Repeat child:(PerlClass name:d) op:<Arith_Plus "+">)
    flags:[
      (EggexFlag negated:F flag:<Expr_Name i>)
      (EggexFlag negated:F flag:<Expr_Name reg_newline>)
    ]
    trans_pref:<Expr_Name ERE>
    canonical_flags:in
  )
)

===== CASE: -n -c = / d+ ; ; ERE / =====


(command.Expr
  keyword:<Lit_Equals "=">
  e:(Eggex
    left:<Arith_Slash />
    regex:(re.Repeat child:(PerlClass name:d) op:<Arith_Plus "+">)
    flags:[]
    trans_pref:<Expr_Name ERE>
    canonical_flags:""
  )
)

===== CASE: -n -c = / d+ ; / =====


(command.Expr
  keyword:<Lit_Equals "=">
  e:(Eggex
    left:<Arith_Slash />
    regex:(re.Repeat child:(PerlClass name:d) op:<Arith_Plus "+">)
    flags:[]
    canonical_flags:""
  )
)

===== CASE: -n -c = / d+ ; ; / =====


  = / d+ ; ; /
             ^
[ -c flag ]:1: Syntax error in expression (near Id.Arith_Slash)

===== CASE: -n -c = / d+ ; ; ; / =====


  = / d+ ; ; ; /
             ^
[ -c flag ]:1: Syntax error in expression (near Id.Op_Semi)
OK  test-eggex-flags
*** Running test-expr-range

===== CASE: -n -c = 1..5 =====


  = 1..5
     ^~
[ -c flag ]:1: Use ..< for half-open range, or ..= for closed range (OILS-ERR-16)

===== CASE: -n -c = 1..<5 =====


(command.Expr
  keyword:<Lit_Equals "=">
  e:(expr.Range
    lower:(Const Expr_DecInt _)
    op:<Expr_DDotLessThan "..<">
    upper:(Const Expr_DecInt _)
  )
)

===== CASE: -n -c = 1..=5 =====


(command.Expr
  keyword:<Lit_Equals "=">
  e:(expr.Range
    lower:(Const Expr_DecInt _)
    op:<Expr_DDotEqual "..=">
    upper:(Const Expr_DecInt _)
  )
)
OK  test-expr-range
*** Running test-fat-arrow

===== CASE: -n -c var x = s => trim() =====


(command.VarDecl
  keyword:<KW_Var var>
  lhs:[(NameType left:<Expr_Name x> name:x)]
  rhs:(expr.FuncCall
    func:(Attribute
      obj:(Var s)
      op:<Expr_RDArrow "=>">
      attr:<Expr_Name trim>
      attr_name:trim
      ctx:expr_context.Store
    )
    args:(ArgList
      left:<Op_LParen "(">
      pos_args:[]
      named_args:[]
      right:<Op_RParen ")">
    )
  )
)

===== CASE: -n -c func f(x Int) => List[Int] { echo hi } =====


(Func
  keyword:<KW_Func func>
  name:<Expr_Name f>
  positional:(ParamGroup
    params:[
      (Param
        blame_tok:<Expr_Name x>
        name:x
        type:(TypeExpr tok:<Expr_Name Int> name:Int)
      )
    ]
  )
  body:(BraceGroup
    left:<Lit_LBrace "{">
    children:[(C (w <Lit_Chars echo>) (w <Lit_Chars hi>))]
    right:<Lit_RBrace "}">
  )
)
OK  test-fat-arrow
*** Running test-float-literals

===== CASE: -n -c = 42.0 =====


(command.Expr keyword:<Lit_Equals "="> e:(Const Expr_Float _))

===== CASE: -n -c = 42_0.0 =====


(command.Expr keyword:<Lit_Equals "="> e:(Const Expr_Float _))

===== CASE: -n -c = 42_.0 =====


  = 42_.0
        ^
[ -c flag ]:1: Syntax error in expression (near Id.Expr_DecInt)

===== CASE: -n -c = 42. =====


  = 42.
       ^
[ -c flag ]:1: Syntax error in expression (near Id.Eof_Real)

===== CASE: -n -c = .333 =====


  = .333
    ^
[ -c flag ]:1: Syntax error in expression (near Id.Expr_Dot)

===== CASE: -n -c = _42.0 =====


  = _42.0
        ^
[ -c flag ]:1: Syntax error in expression (near Id.Expr_DecInt)
OK  test-float-literals
*** Running test-for

===== CASE: -n -c 
  for x in <> {
    echo $x
  }
   =====


    for x in <> {
             ^~
[ -c flag ]:2: Reserved syntax

===== CASE: -n -c 
  for x in <>
  {
    echo $x
  }
   =====


    for x in <>
             ^~
[ -c flag ]:2: Reserved syntax

===== CASE: -n -c 
  for x in < {
    echo $x
  }
   =====


    for x in < {
             ^
[ -c flag ]:2: Reserved syntax

===== CASE: -n -c 
  for x in < > {
    echo $x
  }
   =====


    for x in < > {
             ^
[ -c flag ]:2: Reserved syntax
OK  test-for
*** Running test-for-parse-bare-word

===== CASE: -n -c 
  for x in bare {
    echo $x
  }
   =====


    for x in bare {
             ^~~~
[ -c flag ]:2: Surround this word with either parens or quotes (parse_bare_word)

===== CASE: -n -c 
  for x in a b {
    echo $x
  }
   =====


(command.ForEach
  keyword:<KW_For for>
  iter_names:[x]
  iterable:(for_iter.Words words:[(w <Lit_Chars a>) (w <Lit_Chars b>)])
  body:(BraceGroup
    left:<Lit_LBrace "{">
    children:[(C (w <Lit_Chars echo>) (w ($ x)))]
    right:<Lit_RBrace "}">
  )
)

===== CASE: -n -c 
  for x in *.py {
    echo $x
  }
   =====


(command.ForEach
  keyword:<KW_For for>
  iter_names:[x]
  iterable:(for_iter.Words words:[(w <Lit_Star "*"> <Lit_Chars .py>)])
  body:(BraceGroup
    left:<Lit_LBrace "{">
    children:[(C (w <Lit_Chars echo>) (w ($ x)))]
    right:<Lit_RBrace "}">
  )
)

===== CASE: -n -c 
  for x in "quoted" {
    echo $x
  }
   =====


(command.ForEach
  keyword:<KW_For for>
  iter_names:[x]
  iterable:(for_iter.Words words:[(w (DQ <Lit_Chars quoted>))])
  body:(BraceGroup
    left:<Lit_LBrace "{">
    children:[(C (w <Lit_Chars echo>) (w ($ x)))]
    right:<Lit_RBrace "}">
  )
)
OK  test-for-parse-bare-word
*** Running test-func-def

===== CASE: -n -c func f(p) { var p = foo } =====


  func f(p) { var p = foo }
                  ^
[ -c flag ]:1: 'p' was already declared

===== CASE: -n -c func f(p; n) { var n = foo } =====


  func f(p; n) { var n = foo }
                     ^
[ -c flag ]:1: 'n' was already declared
OK  test-func-def
*** Running test-func-sig

===== CASE: -n -c func f { echo hi } =====


  func f { echo hi }
         ^
[ -c flag ]:1: Syntax error in expression (near Id.Op_LBrace)

===== CASE: -n -c func f () { echo hi } =====


(Func
  keyword:<KW_Func func>
  name:<Expr_Name f>
  body:(BraceGroup
    left:<Lit_LBrace "{">
    children:[(C (w <Lit_Chars echo>) (w <Lit_Chars hi>))]
    right:<Lit_RBrace "}">
  )
)

===== CASE: -n -c func f (a List[Int] = [3,4]) { echo hi } =====


(Func
  keyword:<KW_Func func>
  name:<Expr_Name f>
  positional:(ParamGroup
    params:[
      (Param
        blame_tok:<Expr_Name a>
        name:a
        type:(TypeExpr
          tok:<Expr_Name List>
          name:List
          params:[(TypeExpr tok:<Expr_Name Int> name:Int)]
        )
        default_val:(expr.List
          left:<Op_LBracket "[">
          elts:[(Const Expr_DecInt _) (Const Expr_DecInt _)]
          ctx:expr_context.Store
        )
      )
    ]
  )
  body:(BraceGroup
    left:<Lit_LBrace "{">
    children:[(C (w <Lit_Chars echo>) (w <Lit_Chars hi>))]
    right:<Lit_RBrace "}">
  )
)

===== CASE: -n -c func f (a, b, ...rest; c) { echo hi } =====


(Func
  keyword:<KW_Func func>
  name:<Expr_Name f>
  positional:(ParamGroup
    params:[
      (Param blame_tok:<Expr_Name a> name:a)
      (Param blame_tok:<Expr_Name b> name:b)
    ]
    rest_of:(RestParam blame_tok:<Expr_Name rest> name:rest)
  )
  named:(ParamGroup params:[(Param blame_tok:<Expr_Name c> name:c)])
  body:(BraceGroup
    left:<Lit_LBrace "{">
    children:[(C (w <Lit_Chars echo>) (w <Lit_Chars hi>))]
    right:<Lit_RBrace "}">
  )
)

===== CASE: -n -c func f (a, b, ...rest; c, ...named) { echo hi } =====


(Func
  keyword:<KW_Func func>
  name:<Expr_Name f>
  positional:(ParamGroup
    params:[
      (Param blame_tok:<Expr_Name a> name:a)
      (Param blame_tok:<Expr_Name b> name:b)
    ]
    rest_of:(RestParam blame_tok:<Expr_Name rest> name:rest)
  )
  named:(ParamGroup
    params:[(Param blame_tok:<Expr_Name c> name:c)]
    rest_of:(RestParam blame_tok:<Expr_Name named> name:named)
  )
  body:(BraceGroup
    left:<Lit_LBrace "{">
    children:[(C (w <Lit_Chars echo>) (w <Lit_Chars hi>))]
    right:<Lit_RBrace "}">
  )
)

===== CASE: -n -c func f (a, b, ...rest; c, ...named;) { echo hi } =====


  func f (a, b, ...rest; c, ...named;) { echo hi }
                                    ^
[ -c flag ]:1: Syntax error in expression (near Id.Op_Semi)
OK  test-func-sig
*** Running test-func-var-checker

===== CASE: -n -c 
  func f(x) {
    setvar x = true
  }
   =====


(Func
  keyword:<KW_Func func>
  name:<Expr_Name f>
  positional:(ParamGroup params:[(Param blame_tok:<Expr_Name x> name:x)])
  body:(BraceGroup
    left:<Lit_LBrace "{">
    children:[
      (command.Mutation
        keyword:<KW_SetVar setvar>
        lhs:[<Expr_Name x>]
        op:<Arith_Equal "=">
        rhs:(Const Expr_True _)
      )
    ]
    right:<Lit_RBrace "}">
  )
)

===== CASE: -n -c 
  func f() {
    setvar x = true
  }
   =====


      setvar x = true
             ^
[ -c flag ]:3: setvar couldn't find matching 'var x' (OILS-ERR-10)
OK  test-func-var-checker
*** Running test-hay-assign

===== CASE: -n -c 
name = val
 =====


  name = val
       ^
[ -c flag ]:2: Unexpected = (Hint: use var/setvar, or quote it)

===== CASE: -n -c 
rule {
  x = 42
}
 =====


    x = 42
      ^
[ -c flag ]:3: Unexpected = (Hint: use var/setvar, or quote it)

===== CASE: -n -c 
RULE {
  x = 42
}
 =====


    x = 42
      ^
[ -c flag ]:3: Unexpected = (Hint: use var/setvar, or quote it)

===== CASE: -n -c 
Rule {
  x = 42
}
 =====


(command.Simple
  blame_tok:<Lit_Chars Rule>
  more_env:[]
  words:[(w <Lit_Chars Rule>)]
  block:(LiteralBlock
    brace_group:(BraceGroup
      left:<Lit_LBrace "{">
      children:[
        (command.VarDecl
          lhs:[(NameType left:<Lit_Chars x> name:x)]
          rhs:(Const Expr_DecInt _)
        )
      ]
      right:<Lit_RBrace "}">
    )
    lines:[
      (SourceLine line_num:2 content:"Rule {\n" src:(source.CFlag))
      (SourceLine line_num:3 content:"  x = 42\n" src:...0x7fe854eaa950)
      (SourceLine line_num:4 content:"}\n" src:...0x7fe854eaa950)
    ]
  )
  is_last_cmd:F
)

===== CASE: -n -c 
Rule X Y {
  x = 42
}
 =====


(command.Simple
  blame_tok:<Lit_Chars Rule>
  more_env:[]
  words:[(w <Lit_Chars Rule>) (w <Lit_Chars X>) (w <Lit_Chars Y>)]
  block:(LiteralBlock
    brace_group:(BraceGroup
      left:<Lit_LBrace "{">
      children:[
        (command.VarDecl
          lhs:[(NameType left:<Lit_Chars x> name:x)]
          rhs:(Const Expr_DecInt _)
        )
      ]
      right:<Lit_RBrace "}">
    )
    lines:[
      (SourceLine line_num:2 content:"Rule X Y {\n" src:(source.CFlag))
      (SourceLine line_num:3 content:"  x = 42\n" src:...0x7fdebeee1990)
      (SourceLine line_num:4 content:"}\n" src:...0x7fdebeee1990)
    ]
  )
  is_last_cmd:F
)

===== CASE: -n -c 
RULe {   # inconsistent but OK
  x = 42
}
 =====


(command.Simple
  blame_tok:<Lit_Chars RULe>
  more_env:[]
  words:[(w <Lit_Chars RULe>)]
  block:(LiteralBlock
    brace_group:(BraceGroup
      left:<Lit_LBrace "{">
      children:[
        (command.VarDecl
          lhs:[(NameType left:<Lit_Chars x> name:x)]
          rhs:(Const Expr_DecInt _)
        )
      ]
      right:<Lit_RBrace "}">
    )
    lines:[
      (SourceLine
        line_num:2
        content:"RULe {   # inconsistent but OK\n"
        src:(source.CFlag)
      )
      (SourceLine line_num:3 content:"  x = 42\n" src:...0x7fa01cba4950)
      (SourceLine line_num:4 content:"}\n" src:...0x7fa01cba4950)
    ]
  )
  is_last_cmd:F
)

===== CASE: -n -c 
hay eval :result {

  Rule {
    foo = 42
  }

  bar = 43   # parse error here
}
 =====


    bar = 43   # parse error here
        ^
[ -c flag ]:8: Unexpected = (Hint: use var/setvar, or quote it)

===== CASE: -n -c 
hay define TASK

TASK build {
  foo = 42
}
 =====


    foo = 42
        ^
[ -c flag ]:5: Unexpected = (Hint: use var/setvar, or quote it)

===== CASE: -n -c 
hay define Package/TASK

Package libc {
  TASK build {
    # this is not an attribute, should not be valid
    foo = 42
  }
}
 =====


      foo = 42
          ^
[ -c flag ]:7: Unexpected = (Hint: use var/setvar, or quote it)

===== CASE: -n -c 
hay define Rule

Rule {
  return (x)
}
 =====


    return (x)
           ^
[ -c flag ]:5: Typed return is only allowed inside func
OK  test-hay-assign
*** Running test-hay-shell-assign

===== CASE: -n -c 
hay define Package

Package foo {
  version=1
}
 =====


    version=1
    ^~~~~~~~
[ -c flag ]:5: Use var/setvar to assign in YSH

===== CASE: -n -c 
hay define Package/User

Package foo {
  User bob {
    sudo=1
  }
}
 =====


      sudo=1
      ^~~~~
[ -c flag ]:6: Use var/setvar to assign in YSH

===== CASE: -n -c 
hay define Package/SHELL/User

Package foo {
  SHELL bob {
    sudo=1
    User {
      name = "z"
    }
  }
}
 =====


(command.CommandList
  children:[
    (C
      (w <Lit_Chars hay>)
      (w <Lit_Chars define>)
      (w
        <Lit_Chars Package>
        <Lit_Slash />
        <Lit_Chars SHELL>
        <Lit_Slash />
        <Lit_Chars User>
      )
    )
    (command.Simple
      blame_tok:<Lit_Chars Package>
      more_env:[]
      words:[(w <Lit_Chars Package>) (w <Lit_Chars foo>)]
      block:(LiteralBlock
        brace_group:(BraceGroup
          left:<Lit_LBrace "{">
          children:[
            (command.Simple
              blame_tok:<Lit_Chars SHELL>
              more_env:[]
              words:[(w <Lit_Chars SHELL>) (w <Lit_Chars bob>)]
              block:(LiteralBlock
                brace_group:(BraceGroup
                  left:<Lit_LBrace "{">
                  children:[
                    (command.ShAssignment
                      left:<Lit_VarLike "sudo=">
                      pairs:[
                        (AssignPair
                          left:...0x7f69df4d2c80
                          lhs:(sh_lhs.Name left:...0x7f69df4d2c80 name:sudo)
                          op:assign_op.Equal
                          rhs:(w <Lit_Chars 1>)
                        )
                      ]
                    )
                    (command.Simple
                      blame_tok:<Lit_Chars User>
                      more_env:[]
                      words:[(w <Lit_Chars User>)]
                      block:(LiteralBlock
                        brace_group:(BraceGroup
                          left:<Lit_LBrace "{">
                          children:[
                            (command.VarDecl
                              lhs:[(NameType left:<Lit_Chars name> name:name)]
                              rhs:(DQ <Lit_Chars z>)
                            )
                          ]
                          right:<Lit_RBrace "}">
                        )
                        lines:[
                          (SourceLine
                            line_num:7
                            content:"    User {\n"
                            src:(source.CFlag)
                          )
                          (SourceLine
                            line_num:8
                            content:"      name = \"z\"\n"
                            src:...0x7f69df938950
                          )
                          (SourceLine
                            line_num:9
                            content:"    }\n"
                            src:...0x7f69df938950
                          )
                        ]
                      )
                      is_last_cmd:F
                    )
                  ]
                  right:<Lit_RBrace "}">
                )
                lines:[]
              )
              is_last_cmd:F
            )
          ]
          right:<Lit_RBrace "}">
        )
        lines:[]
      )
      is_last_cmd:F
    )
  ]
)

===== CASE: -n -c 
hay define Package/SHELL/User

Package foo {
  SHELL bob {
    # Disallowed
    # a = b
    User {
      x=1
    }
  }
}
 =====


        x=1
        ^~
[ -c flag ]:9: Use var/setvar to assign in YSH
OK  test-hay-shell-assign
*** Running test-int-literals

===== CASE: -n -c = 42 =====


(command.Expr keyword:<Lit_Equals "="> e:(Const Expr_DecInt _))

===== CASE: -n -c = 42_0 =====


(command.Expr keyword:<Lit_Equals "="> e:(Const Expr_DecInt _))

===== CASE: -n -c = 42_ =====


  = 42_
      ^
[ -c flag ]:1: Units suffix not implemented

===== CASE: -n -c = 42_0_ =====


  = 42_0_
        ^
[ -c flag ]:1: Units suffix not implemented

===== CASE: -n -c = _42 =====


(command.Expr keyword:<Lit_Equals "="> e:(Var _42))
OK  test-int-literals
*** Running test-int-overflow

===== CASE: -n -c = 123456789_123456789_123456789 =====


  = 123456789_123456789_123456789
    ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[ -c flag ]:1: Decimal int constant is too large

===== CASE: -n -c = 0b111000000000000000000000000000000000000000000000000000000000000000000000000000000 =====


  = 0b111000000000000000000000000000000000000000000000000000000000000000000000000000000
    ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[ -c flag ]:1: Binary int constant is too large

===== CASE: -n -c = 0o1234567_1234567_1234567_1234567 =====


  = 0o1234567_1234567_1234567_1234567
    ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[ -c flag ]:1: Octal int constant is too large

===== CASE: -n -c = 0x123456789_123456789_123456789 =====


  = 0x123456789_123456789_123456789
    ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[ -c flag ]:1: Hex int constant is too large
OK  test-int-overflow
*** Running test-invalid_parens

===== CASE: -n -c write -- $f(x) =====


  write -- $f(x)
             ^
[ -c flag ]:1: Unexpected left paren (might need a space before it)

===== CASE: -n -c write -- $f(x) =====


  write -- $f(x)
             ^
[ -c flag ]:1: Space required before (

===== CASE: -n -c write -- @[sorted(x)] =====


  write -- @[sorted(x)]
                   ^
[ -c flag ]:1: Unexpected left paren (might need a space before it)

===== CASE: -n -c write -- @[sorted(x)] =====


(C
  (w <Lit_Chars write>)
  (w <Lit_Chars -->)
  (w
    (word_part.ExprSub
      left:<Lit_AtLBracket "@[">
      child:(expr.FuncCall
        func:(Var sorted)
        args:(ArgList
          left:<Op_LParen "(">
          pos_args:[(Var x)]
          named_args:[]
          right:<Op_RParen ")">
        )
      )
      right:<Op_RBracket "]">
    )
  )
)

===== CASE: -n -c 
f() {
  write -- @[sorted(x)]
}
 =====


    write -- @[sorted(x)]
                     ^
[ -c flag ]:3: Unexpected left paren (might need a space before it)

===== CASE: -n -c 
f() {
  write -- @[sorted(x)]
}
 =====


(command.ShFunction
  name_tok:<Lit_Chars f>
  name:f
  body:(BraceGroup
    left:<Lit_LBrace "{">
    children:[
      (C
        (w <Lit_Chars write>)
        (w <Lit_Chars -->)
        (w
          (word_part.ExprSub
            left:<Lit_AtLBracket "@[">
            child:(expr.FuncCall
              func:(Var sorted)
              args:(ArgList
                left:<Op_LParen "(">
                pos_args:[(Var x)]
                named_args:[]
                right:<Op_RParen ")">
              )
            )
            right:<Op_RBracket "]">
          )
        )
      )
    ]
    right:<Lit_RBrace "}">
  )
)

===== CASE: -n -c 
f() {
  write -- @sorted (( z ))
}
 =====


    write -- @sorted (( z ))
                     ^~
[ -c flag ]:3: Invalid word while parsing command list
OK  test-invalid_parens
*** Running test-lazy-arg-list

===== CASE: -n -c assert [42 === x] =====


(command.Simple
  blame_tok:<Lit_Chars assert>
  more_env:[]
  words:[(w <Lit_Chars assert>)]
  typed_args:(ArgList
    left:<Op_LBracket "[">
    pos_args:[
      (expr.Compare
        left:(Const Expr_DecInt _)
        ops:[<Expr_TEqual "===">]
        comparators:[(Var x)]
      )
    ]
    named_args:[]
    right:<Op_RBracket "]">
  )
  is_last_cmd:F
)

===== CASE: -n -c assert [ 42 === x ] =====


(command.Simple
  blame_tok:<Lit_Chars assert>
  more_env:[]
  words:[(w <Lit_Chars assert>)]
  typed_args:(ArgList
    left:<Op_LBracket "[">
    pos_args:[
      (expr.Compare
        left:(Const Expr_DecInt _)
        ops:[<Expr_TEqual "===">]
        comparators:[(Var x)]
      )
    ]
    named_args:[]
    right:<Op_RBracket "]">
  )
  is_last_cmd:F
)

===== CASE: -n -c assert [42, 43] =====


(command.Simple
  blame_tok:<Lit_Chars assert>
  more_env:[]
  words:[(w <Lit_Chars assert>)]
  typed_args:(ArgList
    left:<Op_LBracket "[">
    pos_args:[(Const Expr_DecInt _) (Const Expr_DecInt _)]
    named_args:[]
    right:<Op_RBracket "]">
  )
  is_last_cmd:F
)

===== CASE: -n -c assert [42, named=true] =====


(command.Simple
  blame_tok:<Lit_Chars assert>
  more_env:[]
  words:[(w <Lit_Chars assert>)]
  typed_args:(ArgList
    left:<Op_LBracket "[">
    pos_args:[(Const Expr_DecInt _)]
    named_args:[(NamedArg name:<Expr_Name named> value:(Const Expr_True _))]
    right:<Op_RBracket "]">
  )
  is_last_cmd:F
)

===== CASE: -n -c assert [42, named=true]; echo hi =====


(command.CommandList
  children:[
    (command.Sentence
      child:(command.Simple
        blame_tok:<Lit_Chars assert>
        more_env:[]
        words:[(w <Lit_Chars assert>)]
        typed_args:(ArgList
          left:<Op_LBracket "[">
          pos_args:[(Const Expr_DecInt _)]
          named_args:[
            (NamedArg name:<Expr_Name named> value:(Const Expr_True _))
          ]
          right:<Op_RBracket "]">
        )
        is_last_cmd:F
      )
      terminator:<Op_Semi ";">
    )
    (C (w <Lit_Chars echo>) (w <Lit_Chars hi>))
  ]
)

===== CASE: -n -c assert [42, named=true] { echo hi } =====


(command.Simple
  blame_tok:<Lit_Chars assert>
  more_env:[]
  words:[(w <Lit_Chars assert>)]
  typed_args:(ArgList
    left:<Op_LBracket "[">
    pos_args:[(Const Expr_DecInt _)]
    named_args:[(NamedArg name:<Expr_Name named> value:(Const Expr_True _))]
    right:<Op_RBracket "]">
  )
  block:(LiteralBlock
    brace_group:(BraceGroup
      left:<Lit_LBrace "{">
      children:[(C (w <Lit_Chars echo>) (w <Lit_Chars hi>))]
      right:<Lit_RBrace "}">
    )
    lines:[
      (SourceLine
        line_num:1
        content:"assert [42, named=true] { echo hi }"
        src:(source.CFlag)
      )
    ]
  )
  is_last_cmd:F
)

===== CASE: -n -c assert [42, named=true]{ echo hi } =====


(command.Simple
  blame_tok:<Lit_Chars assert>
  more_env:[]
  words:[(w <Lit_Chars assert>)]
  typed_args:(ArgList
    left:<Op_LBracket "[">
    pos_args:[(Const Expr_DecInt _)]
    named_args:[(NamedArg name:<Expr_Name named> value:(Const Expr_True _))]
    right:<Op_RBracket "]">
  )
  block:(LiteralBlock
    brace_group:(BraceGroup
      left:<Lit_LBrace "{">
      children:[(C (w <Lit_Chars echo>) (w <Lit_Chars hi>))]
      right:<Lit_RBrace "}">
    )
    lines:[
      (SourceLine
        line_num:1
        content:"assert [42, named=true]{ echo hi }"
        src:(source.CFlag)
      )
    ]
  )
  is_last_cmd:F
)

===== CASE: -n -c assert *.[ch] =====


(C
  (w <Lit_Chars assert>)
  (w
    <Lit_Star "*">
    <Lit_Chars .>
    <Lit_LBracket "[">
    <Lit_Chars ch>
    <Lit_RBracket "]">
  )
)

===== CASE: -n -c assert 42[ch] =====


(C
  (w <Lit_Chars assert>)
  (w <Lit_Chars 42> <Lit_LBracket "["> <Lit_Chars ch> <Lit_RBracket "]">)
)

===== CASE: -n -c echo[] =====


(C (w <Lit_ArrayLhsOpen "echo["> <Lit_RBracket "]">))

===== CASE: -n -c assert [4 =====


  assert [4
           ^
[ -c flag ]:1: Syntax error in expression (near Id.Eof_Real)

===== CASE: -n -c assert [ 4 =====


  assert [ 4
            ^
[ -c flag ]:1: Syntax error in expression (near Id.Eof_Real)

===== CASE: -n -c json write (42) >out =====


(command.Redirect
  child:(command.Simple
    blame_tok:<Lit_Chars json>
    more_env:[]
    words:[(w <Lit_Chars json>) (w <Lit_Chars write>)]
    typed_args:(ArgList
      left:<Op_LParen "(">
      pos_args:[(Const Expr_DecInt _)]
      named_args:[]
      right:<Op_RParen ")">
    )
    is_last_cmd:F
  )
  redirects:[
    (Redir op:<Redir_Great ">"> loc:(redir_loc.Fd fd:1) arg:(w <Lit_Chars out>))
  ]
)

===== CASE: -n -c json write >out (42) =====


(command.Redirect
  child:(command.Simple
    blame_tok:<Lit_Chars json>
    more_env:[]
    words:[(w <Lit_Chars json>) (w <Lit_Chars write>)]
    typed_args:(ArgList
      left:<Op_LParen "(">
      pos_args:[(Const Expr_DecInt _)]
      named_args:[]
      right:<Op_RParen ")">
    )
    is_last_cmd:F
  )
  redirects:[
    (Redir op:<Redir_Great ">"> loc:(redir_loc.Fd fd:1) arg:(w <Lit_Chars out>))
  ]
)

===== CASE: -n -c [ x = y ] =====


(C
  (w <Lit_LBracket "[">)
  (w <Lit_Chars x>)
  (w <Lit_Equals "=">)
  (w <Lit_Chars y>)
  (w <Lit_RBracket "]">)
)
OK  test-lazy-arg-list
*** Running test-lhs-expr

===== CASE: -n -c setvar x.y[z] = 42 =====


(command.Mutation
  keyword:<KW_SetVar setvar>
  lhs:[
    (Subscript
      left:<Op_LBracket "[">
      obj:(Attribute
        obj:(Var x)
        op:<Expr_Dot .>
        attr:<Expr_Name y>
        attr_name:y
        ctx:expr_context.Store
      )
      index:(Var z)
    )
  ]
  op:<Arith_Equal "=">
  rhs:(Const Expr_DecInt _)
)

===== CASE: -n -c setvar a[i][j] = 42 =====


(command.Mutation
  keyword:<KW_SetVar setvar>
  lhs:[
    (Subscript
      left:<Op_LBracket "[">
      obj:(Subscript left:<Op_LBracket "["> obj:(Var a) index:(Var i))
      index:(Var j)
    )
  ]
  op:<Arith_Equal "=">
  rhs:(Const Expr_DecInt _)
)

===== CASE: -n -c setvar a[i], d.key = 42, 43 =====


(command.Mutation
  keyword:<KW_SetVar setvar>
  lhs:[
    (Subscript left:<Op_LBracket "["> obj:(Var a) index:(Var i))
    (Attribute
      obj:(Var d)
      op:<Expr_Dot .>
      attr:<Expr_Name key>
      attr_name:key
      ctx:expr_context.Store
    )
  ]
  op:<Arith_Equal "=">
  rhs:(expr.Tuple
    left:<Expr_DecInt 42>
    elts:[(Const Expr_DecInt _) (Const Expr_DecInt _)]
    ctx:expr_context.Store
  )
)

===== CASE: -n -c setvar a[i], 3 = 42, 43 =====


  setvar a[i], 3 = 42, 43
               ^
[ -c flag ]:1: Can't assign to this expression

===== CASE: -n -c setvar a[i], {}["key"] = 42, 43 =====


  setvar a[i], {}["key"] = 42, 43
               ^
[ -c flag ]:1: Subscript/Attribute not allowed on this LHS expression

===== CASE: -n -c setvar x+y = 42 =====


  setvar x+y = 42
         ^
[ -c flag ]:1: Can't assign to this expression

===== CASE: -n -c setvar x->y = 42 =====


  setvar x->y = 42
          ^~
[ -c flag ]:1: Can't assign to this attribute expr

===== CASE: -n -c setglobal a[{k:3}["k"]]  = 42 =====


(command.Mutation
  keyword:<KW_SetGlobal setglobal>
  lhs:[
    (Subscript
      left:<Op_LBracket "[">
      obj:(Var a)
      index:(Subscript
        left:<Op_LBracket "[">
        obj:(expr.Dict
          left:<Op_LBrace "{">
          keys:[(Const Expr_Name _)]
          values:[(Const Expr_DecInt _)]
        )
        index:(DQ <Lit_Chars k>)
      )
    )
  ]
  op:<Arith_Equal "=">
  rhs:(Const Expr_DecInt _)
)

===== CASE: -n -c setglobal {}["k"] = 42 =====


  setglobal {}["k"] = 42
            ^
[ -c flag ]:1: Subscript/Attribute not allowed on this LHS expression

===== CASE: -n -c setglobal [1,2][0] = 42 =====


  setglobal [1,2][0] = 42
            ^
[ -c flag ]:1: Subscript/Attribute not allowed on this LHS expression
OK  test-lhs-expr
*** Running test-make-these-nicer

===== CASE: -n -c = =====


  =
   ^
[ -c flag ]:1: Syntax error in expression (near Id.Eof_Real)

===== CASE: -n -c call =====


  call
      ^
[ -c flag ]:1: Syntax error in expression (near Id.Eof_Real)

===== CASE: -n -c const d = { name:
42 } =====


  const d = { name:
                   ^
[ -c flag ]:1: Syntax error in expression (near Id.Op_Newline)
OK  test-make-these-nicer
*** Running test-multiline-string

===== CASE: -n -c echo u'''
hi
'''
 =====


(C
  (w <Lit_Chars echo>)
  (w
    (SingleQuoted
      left:<Left_UTSingleQuote "'">
      sval:"hi\n"
      right:<Right_SingleQuote "'">
    )
  )
)

===== CASE: -n -c echo b'''
hi
'''
 =====


(C
  (w <Lit_Chars echo>)
  (w
    (SingleQuoted
      left:<Left_BTSingleQuote "'">
      sval:"hi\n"
      right:<Right_SingleQuote "'">
    )
  )
)

===== CASE: -n -c echo b'''
hi
''
 =====


  echo b'''
          ^
[ -c flag ]:1: Unexpected EOF in single-quoted string that began here

===== CASE: -n -c echo r'''
hi
'''bad
 =====


  '''bad
     ^~~
[ -c flag ]:3: Unexpected token after YSH single-quoted string

===== CASE: -n -c echo u'''
hi
'''bad
 =====


  '''bad
     ^~~
[ -c flag ]:3: Unexpected token after YSH single-quoted string

===== CASE: -n -c echo """
hi
"""bad
 =====


  """bad
     ^~~
[ -c flag ]:3: Unexpected parts after triple quoted string
OK  test-multiline-string
*** Running test-no-const

===== CASE: -n -c const x = 42 =====


(command.VarDecl
  keyword:<KW_Const const>
  lhs:[(NameType left:<Expr_Name x> name:x)]
  rhs:(Const Expr_DecInt _)
)

===== CASE: -n -c 
  proc p {
    const x = 42
  } =====


      const x = 42
      ^~~~~
[ -c flag ]:3: const can't be inside proc or func.  Use var instead.

===== CASE: -n -c 
  func f() {
    const x = 42
  } =====


      const x = 42
      ^~~~~
[ -c flag ]:3: const can't be inside proc or func.  Use var instead.
OK  test-no-const
*** Running test-parse-at

===== CASE: -n -c echo @ =====


  echo @
       ^
[ -c flag ]:1: Literal @ starting a word must be quoted (parse_at_all)

===== CASE: -n -c echo @@ =====


  echo @@
       ^
[ -c flag ]:1: Literal @ starting a word must be quoted (parse_at_all)

===== CASE: -n -c echo @{foo} =====


  echo @{foo}
       ^
[ -c flag ]:1: Literal @ starting a word must be quoted (parse_at_all)

===== CASE: -n -c echo @/foo/ =====


  echo @/foo/
       ^
[ -c flag ]:1: Literal @ starting a word must be quoted (parse_at_all)

===== CASE: -n -c echo @"foo" =====


  echo @"foo"
       ^
[ -c flag ]:1: Literal @ starting a word must be quoted (parse_at_all)
OK  test-parse-at
*** Running test-parse-backslash

===== CASE: -n -c echo \( =====


(C
  (w <Lit_Chars echo>)
  (w (word_part.EscapedLiteral token:<Lit_EscapedChar "\\("> ch:"("))
)

===== CASE: -n -c echo \; =====


(C
  (w <Lit_Chars echo>)
  (w (word_part.EscapedLiteral token:<Lit_EscapedChar "\\;"> ch:";"))
)

===== CASE: -n -c echo ~ =====


(C (w <Lit_Chars echo>) (w (word_part.TildeSub left:<Lit_Tilde "~">)))

===== CASE: -n -c echo \! =====


(C
  (w <Lit_Chars echo>)
  (w (word_part.EscapedLiteral token:<Lit_EscapedChar "\\!"> ch:"!"))
)

===== CASE: -n -c echo \% =====


(C
  (w <Lit_Chars echo>)
  (w (word_part.EscapedLiteral token:<Lit_EscapedChar "\\%"> ch:"%"))
)

===== CASE: -n -c echo \# =====


(C
  (w <Lit_Chars echo>)
  (w (word_part.EscapedLiteral token:<Lit_EscapedChar "\\#"> ch:"#"))
)

===== CASE: -n -c echo \. =====


  echo \.
       ^~
[ -c flag ]:1: Invalid char escape in unquoted word (OILS-ERR-13)

===== CASE: -n -c echo \- =====


  echo \-
       ^~
[ -c flag ]:1: Invalid char escape in unquoted word (OILS-ERR-13)

===== CASE: -n -c echo \/ =====


  echo \/
       ^~
[ -c flag ]:1: Invalid char escape in unquoted word (OILS-ERR-13)

===== CASE: -n -c echo \a =====


  echo \a
       ^~
[ -c flag ]:1: Invalid char escape in unquoted word (OILS-ERR-13)

===== CASE: -n -c echo \Z =====


  echo \Z
       ^~
[ -c flag ]:1: Invalid char escape in unquoted word (OILS-ERR-13)

===== CASE: -n -c echo \0 =====


  echo \0
       ^~
[ -c flag ]:1: Invalid char escape in unquoted word (OILS-ERR-13)

===== CASE: -n -c echo \9 =====


  echo \9
       ^~
[ -c flag ]:1: Invalid char escape in unquoted word (OILS-ERR-13)

===== CASE: -n -c echo \. \- \/ \a \Z \0 \9 =====


(C
  (w <Lit_Chars echo>)
  (w (word_part.EscapedLiteral token:<Lit_EscapedChar "\\."> ch:.))
  (w (word_part.EscapedLiteral token:<Lit_EscapedChar "\\-"> ch:-))
  (w (word_part.EscapedLiteral token:<Lit_EscapedChar "\\/"> ch:/))
  (w (word_part.EscapedLiteral token:<Lit_EscapedChar "\\a"> ch:a))
  (w (word_part.EscapedLiteral token:<Lit_EscapedChar "\\Z"> ch:Z))
  (w (word_part.EscapedLiteral token:<Lit_EscapedChar "\\0"> ch:0))
  (w (word_part.EscapedLiteral token:<Lit_EscapedChar "\\9"> ch:9))
)
OK  test-parse-backslash
*** Running test-parse-brace

===== CASE: -n -c if test -f foo{ echo hi } =====


  if test -f foo{ echo hi }
             ^~~
[ -c flag ]:1: Word has unbalanced { }.  Maybe add a space or quote it like \{
OK  test-parse-brace
*** Running test-parse-dparen

===== CASE: -n -c ((1 > 0 && 43 > 42)) =====


(command.DParen
  left:<Op_DLeftParen "((">
  child:(arith_expr.Binary
    op:<Arith_DAmp "&&">
    left:(arith_expr.Binary
      op:<Arith_Great ">">
      left:(w <Lit_Digits 1>)
      right:(w <Lit_Digits 0>)
    )
    right:(arith_expr.Binary
      op:<Arith_Great ">">
      left:(w <Lit_Digits 43>)
      right:(w <Lit_Digits 42>)
    )
  )
  right:<Op_DRightParen ")">
)

===== CASE: -n -c ((1 > 0 && 43 > 42)) =====


  ((1 > 0 && 43 > 42))
  ^~
[ -c flag ]:1: Bash (( not allowed in YSH (parse_dparen, see OILS-ERR-14 for wart)

===== CASE: -n -c if ((1 > 0 && 43 > 42)); then echo yes; fi =====


(command.If
  if_kw:<KW_If if>
  arms:[
    (IfArm
      keyword:...0x7f148fb65668
      cond:(List_of_command
        (command.Sentence
          child:(command.DParen
            left:<Op_DLeftParen "((">
            child:(arith_expr.Binary
              op:<Arith_DAmp "&&">
              left:(arith_expr.Binary
                op:<Arith_Great ">">
                left:(w <Lit_Digits 1>)
                right:(w <Lit_Digits 0>)
              )
              right:(arith_expr.Binary
                op:<Arith_Great ">">
                left:(w <Lit_Digits 43>)
                right:(w <Lit_Digits 42>)
              )
            )
            right:<Op_DRightParen ")">
          )
          terminator:<Op_Semi ";">
        )
      )
      then_kw:<KW_Then then>
      action:[
        (command.Sentence
          child:(C (w <Lit_Chars echo>) (w <Lit_Chars yes>))
          terminator:<Op_Semi ";">
        )
      ]
      then_tok:...0x7f148fb65c18
    )
  ]
  else_action:[]
  fi_kw:<KW_Fi fi>
)

===== CASE: -n -c if ((1 > 0 && 43 > 42)); then echo yes; fi =====


  if ((1 > 0 && 43 > 42)); then echo yes; fi
     ^~
[ -c flag ]:1: Bash (( not allowed in YSH (parse_dparen, see OILS-ERR-14 for wart)

===== CASE: -n -c for ((x = 1; x < 5; ++x)); do echo $x; done =====


(command.ForExpr
  keyword:<KW_For for>
  init:(arith_expr.BinaryAssign
    op_id:Arith_Equal
    left:<Lit_ArithVarLike x>
    right:(w <Lit_Digits 1>)
  )
  cond:(arith_expr.Binary
    op:<Arith_Less "<">
    left:<Lit_ArithVarLike x>
    right:(w <Lit_Digits 5>)
  )
  update:(arith_expr.UnaryAssign op_id:Arith_DPlus child:<Lit_ArithVarLike x>)
  body:(command.DoGroup
    left:<KW_Do do>
    children:[
      (command.Sentence
        child:(C (w <Lit_Chars echo>) (w ($ x)))
        terminator:<Op_Semi ";">
      )
    ]
    right:<KW_Done done>
  )
)

===== CASE: -n -c for ((x = 1; x < 5; ++x)); do echo $x; done =====


  for ((x = 1; x < 5; ++x)); do echo $x; done
      ^~
[ -c flag ]:1: Bash for loops aren't allowed (parse_dparen)

===== CASE: -n -c if (1 > 0 and 43 > 42) { echo yes } =====


(command.If
  if_kw:<KW_If if>
  arms:[
    (IfArm
      keyword:...0x7f1482111668
      cond:(condition.YshExpr
        e:(expr.Binary
          op:<Expr_And and>
          left:(expr.Compare
            left:(Const Expr_DecInt _)
            ops:[<Arith_Great ">">]
            comparators:[(Const Expr_DecInt _)]
          )
          right:(expr.Compare
            left:(Const Expr_DecInt _)
            ops:[<Arith_Great ">">]
            comparators:[(Const Expr_DecInt _)]
          )
        )
      )
      action:[(C (w <Lit_Chars echo>) (w <Lit_Chars yes>))]
    )
  ]
  else_action:[]
)

===== CASE: -n -c if ( (1 > 0 and 43 > 42) ) { echo yes } =====


(command.If
  if_kw:<KW_If if>
  arms:[
    (IfArm
      keyword:...0x7f815f83b668
      cond:(condition.YshExpr
        e:(expr.Binary
          op:<Expr_And and>
          left:(expr.Compare
            left:(Const Expr_DecInt _)
            ops:[<Arith_Great ">">]
            comparators:[(Const Expr_DecInt _)]
          )
          right:(expr.Compare
            left:(Const Expr_DecInt _)
            ops:[<Arith_Great ">">]
            comparators:[(Const Expr_DecInt _)]
          )
        )
      )
      action:[(C (w <Lit_Chars echo>) (w <Lit_Chars yes>))]
    )
  ]
  else_action:[]
)
OK  test-parse-dparen
*** Running test-parse_dollar

===== CASE: -n -c echo $ =====


(C (w <Lit_Chars echo>) (w <Lit_Dollar "$">))

===== CASE: +O test-parse_dollar -n -c echo $ =====


oils: got invalid option 'test-parse_dollar'

===== CASE: -n -c echo $ =====


  echo $
       ^
[ -c flag ]:1: Literal $ should be quoted like \$

===== CASE: -n -c echo $: =====


(C (w <Lit_Chars echo>) (w <Lit_Dollar "$"> <Lit_Colon ":">))

===== CASE: +O test-parse_dollar -n -c echo $: =====


oils: got invalid option 'test-parse_dollar'

===== CASE: -n -c echo $: =====


  echo $:
       ^
[ -c flag ]:1: Literal $ should be quoted like \$

===== CASE: -n -c echo "$" =====


(C (w <Lit_Chars echo>) (w (DQ <Lit_Dollar "$">)))

===== CASE: +O test-parse_dollar -n -c echo "$" =====


oils: got invalid option 'test-parse_dollar'

===== CASE: -n -c echo "$" =====


  echo "$"
        ^
[ -c flag ]:1: Literal $ should be quoted like \$

===== CASE: -n -c echo "$:" =====


(C (w <Lit_Chars echo>) (w (DQ <Lit_Dollar "$"> <Lit_Chars ":">)))

===== CASE: +O test-parse_dollar -n -c echo "$:" =====


oils: got invalid option 'test-parse_dollar'

===== CASE: -n -c echo "$:" =====


  echo "$:"
        ^
[ -c flag ]:1: Literal $ should be quoted like \$

===== CASE: -n -c echo ${x:-$} =====


(C
  (w <Lit_Chars echo>)
  (w
    (BracedVarSub
      left:<Left_DollarBrace "${">
      token:<VSub_Name x>
      var_name:x
      suffix_op:(suffix_op.Unary
        op:<VTest_ColonHyphen ":-">
        arg_word:(w <Lit_Dollar "$">)
      )
      right:<Right_DollarBrace "}">
    )
  )
)

===== CASE: +O test-parse_dollar -n -c echo ${x:-$} =====


oils: got invalid option 'test-parse_dollar'

===== CASE: -n -c echo ${x:-$} =====


  echo ${x:-$}
            ^
[ -c flag ]:1: Literal $ should be quoted like \$

===== CASE: -n -c echo ${x:-$:} =====


(C
  (w <Lit_Chars echo>)
  (w
    (BracedVarSub
      left:<Left_DollarBrace "${">
      token:<VSub_Name x>
      var_name:x
      suffix_op:(suffix_op.Unary
        op:<VTest_ColonHyphen ":-">
        arg_word:(w <Lit_Dollar "$"> <Lit_Chars ":">)
      )
      right:<Right_DollarBrace "}">
    )
  )
)

===== CASE: +O test-parse_dollar -n -c echo ${x:-$:} =====


oils: got invalid option 'test-parse_dollar'

===== CASE: -n -c echo ${x:-$:} =====


  echo ${x:-$:}
            ^
[ -c flag ]:1: Literal $ should be quoted like \$

===== CASE: -n -c echo "${x:-$}" =====


(C
  (w <Lit_Chars echo>)
  (w
    (DQ
      (BracedVarSub
        left:<Left_DollarBrace "${">
        token:<VSub_Name x>
        var_name:x
        suffix_op:(suffix_op.Unary
          op:<VTest_ColonHyphen ":-">
          arg_word:(w <Lit_Dollar "$">)
        )
        right:<Right_DollarBrace "}">
      )
    )
  )
)

===== CASE: +O test-parse_dollar -n -c echo "${x:-$}" =====


oils: got invalid option 'test-parse_dollar'

===== CASE: -n -c echo "${x:-$}" =====


  echo "${x:-$}"
             ^
[ -c flag ]:1: Literal $ should be quoted like \$

===== CASE: -n -c echo "${x:-$:}" =====


(C
  (w <Lit_Chars echo>)
  (w
    (DQ
      (BracedVarSub
        left:<Left_DollarBrace "${">
        token:<VSub_Name x>
        var_name:x
        suffix_op:(suffix_op.Unary
          op:<VTest_ColonHyphen ":-">
          arg_word:(w <Lit_Dollar "$"> <Lit_Chars ":">)
        )
        right:<Right_DollarBrace "}">
      )
    )
  )
)

===== CASE: +O test-parse_dollar -n -c echo "${x:-$:}" =====


oils: got invalid option 'test-parse_dollar'

===== CASE: -n -c echo "${x:-$:}" =====


  echo "${x:-$:}"
             ^
[ -c flag ]:1: Literal $ should be quoted like \$
OK  test-parse_dollar
*** Running test-place-expr

===== CASE: -n -c read (&x) =====


(command.Simple
  blame_tok:<Lit_Chars read>
  more_env:[]
  words:[(w <Lit_Chars read>)]
  typed_args:(ArgList
    left:<Op_LParen "(">
    pos_args:[(expr.Place blame_tok:<Expr_Name x> var_name:x ops:[])]
    named_args:[]
    right:<Op_RParen ")">
  )
  is_last_cmd:F
)

===== CASE: -n -c read (&x[0]) =====


  read (&x[0])
          ^
[ -c flag ]:1: Places in containers not implemented yet

===== CASE: -n -c read (&x[0][1]) =====


  read (&x[0][1])
          ^
[ -c flag ]:1: Places in containers not implemented yet

===== CASE: -n -c read (&x.key.other) =====


  read (&x.key.other)
          ^
[ -c flag ]:1: Places in containers not implemented yet

===== CASE: -n -c read (&x + 1) =====


(command.Simple
  blame_tok:<Lit_Chars read>
  more_env:[]
  words:[(w <Lit_Chars read>)]
  typed_args:(ArgList
    left:<Op_LParen "(">
    pos_args:[
      (expr.Binary
        op:<Arith_Plus "+">
        left:(expr.Place blame_tok:<Expr_Name x> var_name:x ops:[])
        right:(Const Expr_DecInt _)
      )
    ]
    named_args:[]
    right:<Op_RParen ")">
  )
  is_last_cmd:F
)

===== CASE: -n -c read (&42) =====


  read (&42)
         ^~
[ -c flag ]:1: Syntax error in expression (near Id.Expr_DecInt)

===== CASE: -n -c read (&+) =====


  read (&+)
         ^
[ -c flag ]:1: Syntax error in expression (near Id.Arith_Plus)

===== CASE: -n -c read (&(x)) =====


  read (&(x))
         ^
[ -c flag ]:1: Syntax error in expression (near Id.Op_LParen)
OK  test-place-expr
*** Running test-proc-args

===== CASE: -n -c json write (x) =====


(command.Simple
  blame_tok:<Lit_Chars json>
  more_env:[]
  words:[(w <Lit_Chars json>) (w <Lit_Chars write>)]
  typed_args:(ArgList
    left:<Op_LParen "(">
    pos_args:[(Var x)]
    named_args:[]
    right:<Op_RParen ")">
  )
  is_last_cmd:F
)

===== CASE: -n -c echo $(json write (x)) =====


(C
  (w <Lit_Chars echo>)
  (w
    (CommandSub
      left_token:<Left_DollarParen "$(">
      child:(command.Simple
        blame_tok:<Lit_Chars json>
        more_env:[]
        words:[(w <Lit_Chars json>) (w <Lit_Chars write>)]
        typed_args:(ArgList
          left:<Op_LParen "(">
          pos_args:[(Var x)]
          named_args:[]
          right:<Op_RParen ")">
        )
        is_last_cmd:F
      )
      right:<Eof_RParen ")">
    )
  )
)

===== CASE: -n -c var result = $(json write (x)) =====


(command.VarDecl
  keyword:<KW_Var var>
  lhs:[(NameType left:<Expr_Name result> name:result)]
  rhs:(CommandSub
    left_token:<Left_DollarParen "$(">
    child:(command.Simple
      blame_tok:<Lit_Chars json>
      more_env:[]
      words:[(w <Lit_Chars json>) (w <Lit_Chars write>)]
      typed_args:(ArgList
        left:<Op_LParen "(">
        pos_args:[(Var x)]
        named_args:[]
        right:<Op_RParen ")">
      )
      is_last_cmd:F
    )
    right:<Eof_RParen ")">
  )
)

===== CASE: -n -c json write (x, y); echo hi =====


(command.CommandList
  children:[
    (command.Sentence
      child:(command.Simple
        blame_tok:<Lit_Chars json>
        more_env:[]
        words:[(w <Lit_Chars json>) (w <Lit_Chars write>)]
        typed_args:(ArgList
          left:<Op_LParen "(">
          pos_args:[(Var x) (Var y)]
          named_args:[]
          right:<Op_RParen ")">
        )
        is_last_cmd:F
      )
      terminator:<Op_Semi ";">
    )
    (C (w <Lit_Chars echo>) (w <Lit_Chars hi>))
  ]
)

===== CASE: -n -c 
json write (x, name = "value")
echo hi
 =====


(command.CommandList
  children:[
    (command.Simple
      blame_tok:<Lit_Chars json>
      more_env:[]
      words:[(w <Lit_Chars json>) (w <Lit_Chars write>)]
      typed_args:(ArgList
        left:<Op_LParen "(">
        pos_args:[(Var x)]
        named_args:[
          (NamedArg name:<Expr_Name name> value:(DQ <Lit_Chars value>))
        ]
        right:<Op_RParen ")">
      )
      is_last_cmd:F
    )
    (C (w <Lit_Chars echo>) (w <Lit_Chars hi>))
  ]
)

===== CASE: -n -c json write (x) { echo hi } =====


(command.Simple
  blame_tok:<Lit_Chars json>
  more_env:[]
  words:[(w <Lit_Chars json>) (w <Lit_Chars write>)]
  typed_args:(ArgList
    left:<Op_LParen "(">
    pos_args:[(Var x)]
    named_args:[]
    right:<Op_RParen ")">
  )
  block:(LiteralBlock
    brace_group:(BraceGroup
      left:<Lit_LBrace "{">
      children:[(C (w <Lit_Chars echo>) (w <Lit_Chars hi>))]
      right:<Lit_RBrace "}">
    )
    lines:[
      (SourceLine
        line_num:1
        content:"json write (x) { echo hi }"
        src:(source.CFlag)
      )
    ]
  )
  is_last_cmd:F
)

===== CASE: -n -c 
json write (x) {
  echo hi
} =====


(command.Simple
  blame_tok:<Lit_Chars json>
  more_env:[]
  words:[(w <Lit_Chars json>) (w <Lit_Chars write>)]
  typed_args:(ArgList
    left:<Op_LParen "(">
    pos_args:[(Var x)]
    named_args:[]
    right:<Op_RParen ")">
  )
  block:(LiteralBlock
    brace_group:(BraceGroup
      left:<Lit_LBrace "{">
      children:[(C (w <Lit_Chars echo>) (w <Lit_Chars hi>))]
      right:<Lit_RBrace "}">
    )
    lines:[
      (SourceLine line_num:2 content:"json write (x) {\n" src:(source.CFlag))
      (SourceLine line_num:3 content:"  echo hi\n" src:...0x7f845a794950)
      (SourceLine line_num:4 content:"}" src:...0x7f845a794950)
    ]
  )
  is_last_cmd:F
)

===== CASE: -n -c json write (
    x,
    y,
    z
  ) =====


(command.Simple
  blame_tok:<Lit_Chars json>
  more_env:[]
  words:[(w <Lit_Chars json>) (w <Lit_Chars write>)]
  typed_args:(ArgList
    left:<Op_LParen "(">
    pos_args:[(Var x) (Var y) (Var z)]
    named_args:[]
    right:<Op_RParen ")">
  )
  is_last_cmd:F
)

===== CASE: -n -c json write () =====


  json write ()
             ^
[ -c flag ]:1: Empty arg list not allowed

===== CASE: -n -c json write ( ) =====


  json write ( )
             ^
[ -c flag ]:1: Empty arg list not allowed

===== CASE: -n -c json write(x) =====


  json write(x)
            ^
[ -c flag ]:1: Space required before (

===== CASE: -n -c json write() =====


  json write()
            ^
[ -c flag ]:1: Space required before (

===== CASE: -n -c f(x) =====


  f(x)
   ^
[ -c flag ]:1: Space required before (
OK  test-proc-args
*** Running test-proc-def

===== CASE: -n -c proc p(w) { var w = foo } =====


  proc p(w) { var w = foo }
                  ^
[ -c flag ]:1: 'w' was already declared

===== CASE: -n -c proc p(w; p) { var p = foo } =====


  proc p(w; p) { var p = foo }
                     ^
[ -c flag ]:1: 'p' was already declared

===== CASE: -n -c proc p(w; p; n, n2) { var n2 = foo } =====


  proc p(w; p; n, n2) { var n2 = foo }
                            ^~
[ -c flag ]:1: 'n2' was already declared

===== CASE: -n -c proc p(w; p; n, n2; b) { var b = foo } =====


  proc p(w; p; n, n2; b) { var b = foo }
                               ^
[ -c flag ]:1: 'b' was already declared
OK  test-proc-def
*** Running test-proc-sig

===== CASE: -n -c proc f[] { echo hi } =====


  proc f[] { echo hi }
       ^~
[ -c flag ]:1: Invalid proc name 'f['

===== CASE: -n -c proc : { echo hi } =====


  proc : { echo hi }
       ^
[ -c flag ]:1: Invalid proc name ':'

===== CASE: -n -c proc foo::bar { echo hi } =====


  proc foo::bar { echo hi }
          ^
[ -c flag ]:1: Syntax error in expression (near Id.Arith_Colon)
OK  test-proc-sig
*** Running test-regex-literals

===== CASE: -n -c var x = / ! / =====


  var x = / ! /
              ^
[ -c flag ]:1: Syntax error in expression (near Id.Arith_Slash)

===== CASE: -n -c var x = / ![a-z] / =====


(command.VarDecl
  keyword:<KW_Var var>
  lhs:[(NameType left:<Expr_Name x> name:x)]
  rhs:(Eggex
    left:<Arith_Slash />
    regex:(re.CharClassLiteral
      negated:T
      terms:[
        (CharRange
          start:(CharCode blame_tok:<Expr_Name a> i:97 u_braced:F)
          end:(CharCode blame_tok:<Expr_Name z> i:122 u_braced:F)
        )
      ]
    )
    flags:[]
    canonical_flags:""
  )
)

===== CASE: -n -c var x = / !d / =====


(command.VarDecl
  keyword:<KW_Var var>
  lhs:[(NameType left:<Expr_Name x> name:x)]
  rhs:(Eggex
    left:<Arith_Slash />
    regex:(PerlClass negated:<Expr_Bang "!"> name:d)
    flags:[]
    canonical_flags:""
  )
)

===== CASE: -n -c var x = / !! / =====


  var x = / !! /
               ^
[ -c flag ]:1: Syntax error in expression (near Id.Arith_Slash)

===== CASE: -n -c var x = /[a-zA-Z]/ =====


  var x = /[a-zA-Z]/
                ^
[ -c flag ]:1: Syntax error in expression (near Id.Arith_Minus)

===== CASE: -n -c var x = /[a-z0-9]/ =====


  var x = /[a-z0-9]/
                ^
[ -c flag ]:1: Syntax error in expression (near Id.Arith_Minus)

===== CASE: -n -c var x = /[a-zz]/ =====


  var x = /[a-zz]/
              ^~
[ -c flag ]:1: Range start/end shouldn't have more than one character

===== CASE: -n -c var x = /['ab'-'z']/ =====


  var x = /['ab'-'z']/
            ^
[ -c flag ]:1: Range start/end shouldn't have more than one character

===== CASE: -n -c var x = /[$a-${z}]/ =====


  var x = /[$a-${z}]/
            ^~
[ -c flag ]:1: Syntax error in expression (near Id.VSub_DollarName)

===== CASE: -n -c var x = /[abc]/ =====


  var x = /[abc]/
            ^~~
[ -c flag ]:1: 'abc' isn't a character class

===== CASE: -n -c var x = /[% _]/ =====


  var x = /[% _]/
            ^
[ -c flag ]:1: Syntax error in expression (near Id.Arith_Percent)
OK  test-regex-literals
*** Running test-return-args

===== CASE: -n -c 
  func foo(x) {
    return (x)
  }
   =====


(Func
  keyword:<KW_Func func>
  name:<Expr_Name foo>
  positional:(ParamGroup params:[(Param blame_tok:<Expr_Name x> name:x)])
  body:(BraceGroup
    left:<Lit_LBrace "{">
    children:[(command.Retval keyword:<ControlFlow_Return return> val:(Var x))]
    right:<Lit_RBrace "}">
  )
)

===== CASE: -n -c 
  func foo(x) {
    return ()
  }
   =====


      return ()
      ^~~~~~
[ -c flag ]:3: shell functions can't be defined inside proc or func

===== CASE: -n -c 
  func foo(x) {
    return (named=x)
  }
   =====


      return (named=x)
             ^
[ -c flag ]:3: Typed return expects one argument

===== CASE: -n -c 
  func foo(x) {
    return (x, named=x)
  }
   =====


      return (x, named=x)
             ^
[ -c flag ]:3: Typed return doesn't take named arguments

===== CASE: -n -c 
  func foo(x) {
    return (x, x)
  }
   =====


      return (x, x)
             ^
[ -c flag ]:3: Typed return expects one argument

===== CASE: -n -c 
  func foo() {
    return [42]
  }
   =====


      return [42]
             ^
[ -c flag ]:3: Expected ( in typed return

===== CASE: -n -c 
  func foo() {
    return [42 + a[i]]
  }
   =====


      return [42 + a[i]]
             ^
[ -c flag ]:3: Expected ( in typed return
OK  test-return-args
*** Running test-setvar

===== CASE: -n -c 
  proc p(x) {
    var y = 1
    setvar y = 42
  }
   =====


(Proc
  keyword:<KW_Proc proc>
  name:<Lit_Chars p>
  sig:(proc_sig.Closed
    word:(ParamGroup params:[(Param blame_tok:<Expr_Name x> name:x)])
  )
  body:(BraceGroup
    left:<Lit_LBrace "{">
    children:[
      (command.VarDecl
        keyword:<KW_Var var>
        lhs:[(NameType left:<Expr_Name y> name:y)]
        rhs:(Const Expr_DecInt _)
      )
      (command.Mutation
        keyword:<KW_SetVar setvar>
        lhs:[<Expr_Name y>]
        op:<Arith_Equal "=">
        rhs:(Const Expr_DecInt _)
      )
    ]
    right:<Lit_RBrace "}">
  )
)

===== CASE: -n -c 
  proc p(x) {
    var y = 1
    setvar L = "L"  # ERROR: not declared
  }
   =====


      setvar L = "L"  # ERROR: not declared
             ^
[ -c flag ]:4: setvar couldn't find matching 'var L' (OILS-ERR-10)

===== CASE: -n -c 
  proc p(x) {
    var y = 1
    setvar L[0] = "L"  # ERROR: not declared
  }
   =====


      setvar L[0] = "L"  # ERROR: not declared
             ^
[ -c flag ]:4: setvar couldn't find matching 'var L' (OILS-ERR-10)

===== CASE: -n -c 
  proc p(x) {
    var y = 1
    setvar d.key = "v"  # ERROR: not declared
  }
   =====


      setvar d.key = "v"  # ERROR: not declared
             ^
[ -c flag ]:4: setvar couldn't find matching 'var d' (OILS-ERR-10)

===== CASE: -n -c 
  proc p(x) {
    setvar x = "X"  # is mutating params allowed?  I guess why not.
  }
   =====


(Proc
  keyword:<KW_Proc proc>
  name:<Lit_Chars p>
  sig:(proc_sig.Closed
    word:(ParamGroup params:[(Param blame_tok:<Expr_Name x> name:x)])
  )
  body:(BraceGroup
    left:<Lit_LBrace "{">
    children:[
      (command.Mutation
        keyword:<KW_SetVar setvar>
        lhs:[<Expr_Name x>]
        op:<Arith_Equal "=">
        rhs:(DQ <Lit_Chars X>)
      )
    ]
    right:<Lit_RBrace "}">
  )
)
OK  test-setvar
*** Running test-sh-assign

===== CASE: -n -c x=y =====


(command.ShAssignment
  left:<Lit_VarLike "x=">
  pairs:[
    (AssignPair
      left:...0x7fc5c1dde668
      lhs:(sh_lhs.Name left:...0x7fc5c1dde668 name:x)
      op:assign_op.Equal
      rhs:(w <Lit_Chars y>)
    )
  ]
)

===== CASE: -n -c x=y echo hi =====


(command.Simple
  blame_tok:<Lit_Chars echo>
  more_env:[(EnvPair left:<Lit_VarLike "x="> name:x val:(w <Lit_Chars y>))]
  words:[(w <Lit_Chars echo>) (w <Lit_Chars hi>)]
  is_last_cmd:F
)

===== CASE: -n -c f() { x=y; } =====


(command.ShFunction
  name_tok:<Lit_Chars f>
  name:f
  body:(BraceGroup
    left:<Lit_LBrace "{">
    children:[
      (command.Sentence
        child:(command.ShAssignment
          left:<Lit_VarLike "x=">
          pairs:[
            (AssignPair
              left:...0x7fdd89029738
              lhs:(sh_lhs.Name left:...0x7fdd89029738 name:x)
              op:assign_op.Equal
              rhs:(w <Lit_Chars y>)
            )
          ]
        )
        terminator:<Op_Semi ";">
      )
    ]
    right:<Lit_RBrace "}">
  )
)

===== CASE: -n -c func f() { x=y; } =====


  func f() { x=y; }
             ^~
[ -c flag ]:1: Use var/setvar to assign in YSH

===== CASE: -n -c proc p { x=y; } =====


  proc p { x=y; }
           ^~
[ -c flag ]:1: Use var/setvar to assign in YSH

===== CASE: -n -c { x=y; } =====


(BraceGroup
  left:<Lit_LBrace "{">
  children:[
    (command.Sentence
      child:(command.ShAssignment
        left:<Lit_VarLike "x=">
        pairs:[
          (AssignPair
            left:...0x7febdb5d4738
            lhs:(sh_lhs.Name left:...0x7febdb5d4738 name:x)
            op:assign_op.Equal
            rhs:(w <Lit_Chars y>)
          )
        ]
      )
      terminator:<Op_Semi ";">
    )
  ]
  right:<Lit_RBrace "}">
)

===== CASE: -n -c ( x=y; ) =====


(command.Subshell
  left:<Op_LParen "(">
  child:(command.Sentence
    child:(command.ShAssignment
      left:<Lit_VarLike "x=">
      pairs:[
        (AssignPair
          left:...0x7f4f2d8ec738
          lhs:(sh_lhs.Name left:...0x7f4f2d8ec738 name:x)
          op:assign_op.Equal
          rhs:(w <Lit_Chars y>)
        )
      ]
    )
    terminator:<Op_Semi ";">
  )
  right:<Right_Subshell ")">
  is_last_cmd:F
)

===== CASE: -o ysh:upgrade -n -c x=y =====


(command.ShAssignment
  left:<Lit_VarLike "x=">
  pairs:[
    (AssignPair
      left:...0x7fa32b61f668
      lhs:(sh_lhs.Name left:...0x7fa32b61f668 name:x)
      op:assign_op.Equal
      rhs:(w <Lit_Chars y>)
    )
  ]
)
OK  test-sh-assign
*** Running test-string-literals

===== CASE: -n -c echo r'hi'; =====


(command.Sentence
  child:(C
    (w <Lit_Chars echo>)
    (w
      (SingleQuoted
        left:<Left_RSingleQuote "'">
        sval:hi
        right:<Right_SingleQuote "'">
      )
    )
  )
  terminator:<Op_Semi ";">
)

===== CASE: -n -c echo u'hi' =====


(C
  (w <Lit_Chars echo>)
  (w
    (SingleQuoted
      left:<Left_USingleQuote "'">
      sval:hi
      right:<Right_SingleQuote "'">
    )
  )
)

===== CASE: -n -c (echo u'hi') =====


(command.Subshell
  left:<Op_LParen "(">
  child:(C
    (w <Lit_Chars echo>)
    (w
      (SingleQuoted
        left:<Left_USingleQuote "'">
        sval:hi
        right:<Right_SingleQuote "'">
      )
    )
  )
  right:<Right_Subshell ")">
  is_last_cmd:F
)

===== CASE: -n -c echo b'hi'trailing =====


  echo b'hi'trailing
            ^~~~~~~~
[ -c flag ]:1: Unexpected token after YSH single-quoted string

===== CASE: -n -c echo b'hi'#notcomment =====


  echo b'hi'#notcomment
            ^
[ -c flag ]:1: Unexpected token after YSH single-quoted string

===== CASE: -n -c echo 'hi'#notcomment =====


(C (w <Lit_Chars echo>) (w (SQ hi) <Lit_Pound "#"> <Lit_Chars notcomment>))
OK  test-string-literals
*** Running test-type-expr

===== CASE: -n -c var x: Int = f() =====


(command.VarDecl
  keyword:<KW_Var var>
  lhs:[
    (NameType
      left:<Expr_Name x>
      name:x
      typ:(TypeExpr tok:<Expr_Name Int> name:Int)
    )
  ]
  rhs:(expr.FuncCall
    func:(Var f)
    args:(ArgList
      left:<Op_LParen "(">
      pos_args:[]
      named_args:[]
      right:<Op_RParen ")">
    )
  )
)

===== CASE: -n -c var x Int = f() =====


(command.VarDecl
  keyword:<KW_Var var>
  lhs:[
    (NameType
      left:<Expr_Name x>
      name:x
      typ:(TypeExpr tok:<Expr_Name Int> name:Int)
    )
  ]
  rhs:(expr.FuncCall
    func:(Var f)
    args:(ArgList
      left:<Op_LParen "(">
      pos_args:[]
      named_args:[]
      right:<Op_RParen ")">
    )
  )
)

===== CASE: -n -c proc p (; x Int, y Int; ) { echo hi } =====


(Proc
  keyword:<KW_Proc proc>
  name:<Lit_Chars p>
  sig:(proc_sig.Closed
    positional:(ParamGroup
      params:[
        (Param
          blame_tok:<Expr_Name x>
          name:x
          type:(TypeExpr tok:<Expr_Name Int> name:Int)
        )
        (Param
          blame_tok:<Expr_Name y>
          name:y
          type:(TypeExpr tok:<Expr_Name Int> name:Int)
        )
      ]
    )
  )
  body:(BraceGroup
    left:<Lit_LBrace "{">
    children:[(C (w <Lit_Chars echo>) (w <Lit_Chars hi>))]
    right:<Lit_RBrace "}">
  )
)

===== CASE: -n -c func f (x Int, y Int; z Int = 0) { echo hi } =====


(Func
  keyword:<KW_Func func>
  name:<Expr_Name f>
  positional:(ParamGroup
    params:[
      (Param
        blame_tok:<Expr_Name x>
        name:x
        type:(TypeExpr tok:<Expr_Name Int> name:Int)
      )
      (Param
        blame_tok:<Expr_Name y>
        name:y
        type:(TypeExpr tok:<Expr_Name Int> name:Int)
      )
    ]
  )
  named:(ParamGroup
    params:[
      (Param
        blame_tok:<Expr_Name z>
        name:z
        type:(TypeExpr tok:<Expr_Name Int> name:Int)
        default_val:(Const Expr_DecInt _)
      )
    ]
  )
  body:(BraceGroup
    left:<Lit_LBrace "{">
    children:[(C (w <Lit_Chars echo>) (w <Lit_Chars hi>))]
    right:<Lit_RBrace "}">
  )
)
OK  test-type-expr
*** Running test-typed-proc

===== CASE: -n -c typed proc p(words) { echo hi } =====


(Proc
  keyword:<KW_Proc proc>
  name:<Lit_Chars p>
  sig:(proc_sig.Closed
    word:(ParamGroup params:[(Param blame_tok:<Expr_Name words> name:words)])
  )
  body:(BraceGroup
    left:<Lit_LBrace "{">
    children:[(C (w <Lit_Chars echo>) (w <Lit_Chars hi>))]
    right:<Lit_RBrace "}">
  )
)

===== CASE: -n -c typed zzz p(words) { echo hi } =====


  typed zzz p(words) { echo hi }
        ^~~
[ -c flag ]:1: Expected 'proc' after 'typed'

===== CASE: -n -c typed p(words) { echo hi } =====


  typed p(words) { echo hi }
        ^
[ -c flag ]:1: Expected 'proc' after 'typed'
OK  test-typed-proc
*** Running test-units-suffix

===== CASE: -n -c = 100 M M =====


  = 100 M M
          ^
[ -c flag ]:1: Syntax error in expression (near Id.Expr_Name)

===== CASE: -n -c = 100 M; echo =====


  = 100 M; echo
        ^
[ -c flag ]:1: Units suffix not implemented

===== CASE: -n -c = 100 Mi; echo =====


  = 100 Mi; echo
        ^~
[ -c flag ]:1: Units suffix not implemented

===== CASE: -n -c = 9.9 Mi; echo =====


  = 9.9 Mi; echo
        ^~
[ -c flag ]:1: unix suffix implemented

===== CASE: -n -c = 9.9e-1 Mi; echo =====


  = 9.9e-1 Mi; echo
           ^~
[ -c flag ]:1: unix suffix implemented

===== CASE: -n -c = 100Mi =====


  = 100Mi
       ^~
[ -c flag ]:1: Units suffix not implemented

===== CASE: -n -c = [100 Mi, 200 Mi] =====


  = [100 Mi, 200 Mi]
         ^~
[ -c flag ]:1: Units suffix not implemented

===== CASE: -n -c = {[42 Ki]: 43 Ki} =====


  = {[42 Ki]: 43 Ki}
         ^~
[ -c flag ]:1: Units suffix not implemented
OK  test-units-suffix
*** Running test-unknown-boolops

===== CASE: -n -c = a && b =====


  = a && b
      ^~
[ -c flag ]:1: Use 'and' in expression mode (OILS-ERR-15)

===== CASE: -n -c = a || b =====


  = a || b
      ^~
[ -c flag ]:1: Use 'or' in expression mode (OILS-ERR-15)

===== CASE: -n -c = !a =====


  = !a
    ^
[ -c flag ]:1: Syntax error in expression (near Id.Expr_Bang)
OK  test-unknown-boolops
*** Running test-var-decl

===== CASE: -n -c 
  proc p(x) {
    echo hi
    var x = 2  # Cannot redeclare param
  }
   =====


      var x = 2  # Cannot redeclare param
          ^
[ -c flag ]:4: 'x' was already declared

===== CASE: -n -c 
  proc p {
    var x = 1
    echo hi
    var x = 2  # Cannot redeclare local
  }
   =====


      var x = 2  # Cannot redeclare local
          ^
[ -c flag ]:5: 'x' was already declared

===== CASE: -n -c 
  proc p(x, :out) {
    var out = 2   # Cannot redeclare out param
  }
   =====


    proc p(x, :out) {
              ^
[ -c flag ]:2: Syntax error in expression (near Id.Arith_Colon)

===== CASE: -n -c 
  proc p {
    var out = 2   # Cannot redeclare out param
    cd /tmp { 
      var out = 3
    }
  }
   =====


        var out = 3
            ^~~
[ -c flag ]:5: 'out' was already declared

===== CASE: -n -c 
  var x = 1
  proc p {
    echo hi
    var x = 2
  }

  proc p2 {
    var x = 3
  }
   =====


(command.CommandList
  children:[
    (command.VarDecl
      keyword:<KW_Var var>
      lhs:[(NameType left:<Expr_Name x> name:x)]
      rhs:(Const Expr_DecInt _)
    )
    (Proc
      keyword:<KW_Proc proc>
      name:<Lit_Chars p>
      sig:(proc_sig.Open)
      body:(BraceGroup
        left:<Lit_LBrace "{">
        children:[
          (C (w <Lit_Chars echo>) (w <Lit_Chars hi>))
          (command.VarDecl
            keyword:<KW_Var var>
            lhs:[(NameType left:<Expr_Name x> name:x)]
            rhs:(Const Expr_DecInt _)
          )
        ]
        right:<Lit_RBrace "}">
      )
    )
    (Proc
      keyword:<KW_Proc proc>
      name:<Lit_Chars p2>
      sig:...0x7f755afb0510
      body:(BraceGroup
        left:<Lit_LBrace "{">
        children:[
          (command.VarDecl
            keyword:<KW_Var var>
            lhs:[(NameType left:<Expr_Name x> name:x)]
            rhs:(Const Expr_DecInt _)
          )
        ]
        right:<Lit_RBrace "}">
      )
    )
  ]
)
OK  test-var-decl
*** Running test-ysh-case

===== CASE: -n -c 
  case (x) {
    (else) { = 1; }
  }
   =====


(command.Case
  case_kw:<KW_Case case>
  to_match:(case_arg.YshExpr e:(Var x))
  arms_start:<Lit_LBrace "{">
  arms:[
    (CaseArm
      left:<Op_LParen "(">
      pattern:(pat.Else)
      middle:<Lit_LBrace "{">
      action:[
        (command.Sentence
          child:(command.Expr keyword:<Lit_Equals "="> e:(Const Expr_DecInt _))
          terminator:<Op_Semi ";">
        )
      ]
      right:<Lit_RBrace "}">
    )
  ]
  arms_end:<Lit_RBrace "}">
)

===== CASE: -n -c 
  var myexpr = ^[123]

  case (123) {
    (myexpr) { echo 1 }
  }
   =====


(command.CommandList
  children:[
    (command.VarDecl
      keyword:<KW_Var var>
      lhs:[(NameType left:<Expr_Name myexpr> name:myexpr)]
      rhs:(expr.Literal inner:(Const Expr_DecInt _))
    )
    (command.Case
      case_kw:<KW_Case case>
      to_match:(case_arg.YshExpr e:(Const Expr_DecInt _))
      arms_start:<Lit_LBrace "{">
      arms:[
        (CaseArm
          left:<Op_LParen "(">
          pattern:(pat.YshExprs exprs:[(Var myexpr)])
          middle:<Lit_LBrace "{">
          action:[(C (w <Lit_Chars echo>) (w <Lit_Chars 1>))]
          right:<Lit_RBrace "}">
        )
      ]
      arms_end:<Lit_RBrace "}">
    )
  ]
)

===== CASE: -n -c 
  case (x) {
    (else) { echo 1 }
  }
   =====


(command.Case
  case_kw:<KW_Case case>
  to_match:(case_arg.YshExpr e:(Var x))
  arms_start:<Lit_LBrace "{">
  arms:[
    (CaseArm
      left:<Op_LParen "(">
      pattern:(pat.Else)
      middle:<Lit_LBrace "{">
      action:[(C (w <Lit_Chars echo>) (w <Lit_Chars 1>))]
      right:<Lit_RBrace "}">
    )
  ]
  arms_end:<Lit_RBrace "}">
)

===== CASE: -n -c 
  case (x) {
    (else) { = 1 }
  }
   =====


(command.Case
  case_kw:<KW_Case case>
  to_match:(case_arg.YshExpr e:(Var x))
  arms_start:<Lit_LBrace "{">
  arms:[
    (CaseArm
      left:<Op_LParen "(">
      pattern:(pat.Else)
      middle:<Lit_LBrace "{">
      action:[(command.Expr keyword:<Lit_Equals "="> e:(Const Expr_DecInt _))]
      right:<Lit_RBrace "}">
    )
  ]
  arms_end:<Lit_RBrace "}">
)

===== CASE: -n -c 
  case (x) {
    (else) { = 1 } 
 
  }
   =====


(command.Case
  case_kw:<KW_Case case>
  to_match:(case_arg.YshExpr e:(Var x))
  arms_start:<Lit_LBrace "{">
  arms:[
    (CaseArm
      left:<Op_LParen "(">
      pattern:(pat.Else)
      middle:<Lit_LBrace "{">
      action:[(command.Expr keyword:<Lit_Equals "="> e:(Const Expr_DecInt _))]
      right:<Lit_RBrace "}">
    )
  ]
  arms_end:<Lit_RBrace "}">
)

===== CASE: -n -c 
  case (x) {
    (else) { = 1 }  # Comment
  }
   =====


(command.Case
  case_kw:<KW_Case case>
  to_match:(case_arg.YshExpr e:(Var x))
  arms_start:<Lit_LBrace "{">
  arms:[
    (CaseArm
      left:<Op_LParen "(">
      pattern:(pat.Else)
      middle:<Lit_LBrace "{">
      action:[(command.Expr keyword:<Lit_Equals "="> e:(Const Expr_DecInt _))]
      right:<Lit_RBrace "}">
    )
  ]
  arms_end:<Lit_RBrace "}">
)

===== CASE: -n -c 
  case (3) {
    (3) { echo hi }
    # comment line
  }
   =====


(command.Case
  case_kw:<KW_Case case>
  to_match:(case_arg.YshExpr e:(Const Expr_DecInt _))
  arms_start:<Lit_LBrace "{">
  arms:[
    (CaseArm
      left:<Op_LParen "(">
      pattern:(pat.YshExprs exprs:[(Const Expr_DecInt _)])
      middle:<Lit_LBrace "{">
      action:[(C (w <Lit_Chars echo>) (w <Lit_Chars hi>))]
      right:<Lit_RBrace "}">
    )
  ]
  arms_end:<Lit_RBrace "}">
)

===== CASE: -n -c 
  case (x) {
    (else) { echo 1 } 
  }
   =====


(command.Case
  case_kw:<KW_Case case>
  to_match:(case_arg.YshExpr e:(Var x))
  arms_start:<Lit_LBrace "{">
  arms:[
    (CaseArm
      left:<Op_LParen "(">
      pattern:(pat.Else)
      middle:<Lit_LBrace "{">
      action:[(C (w <Lit_Chars echo>) (w <Lit_Chars 1>))]
      right:<Lit_RBrace "}">
    )
  ]
  arms_end:<Lit_RBrace "}">
)

===== CASE: -n -c 
  case (foo) { (else) { echo } }
   =====


(command.Case
  case_kw:<KW_Case case>
  to_match:(case_arg.YshExpr e:(Var foo))
  arms_start:<Lit_LBrace "{">
  arms:[
    (CaseArm
      left:<Op_LParen "(">
      pattern:(pat.Else)
      middle:<Lit_LBrace "{">
      action:[(C (w <Lit_Chars echo>))]
      right:<Lit_RBrace "}">
    )
  ]
  arms_end:<Lit_RBrace "}">
)

===== CASE: -n -c 
  case (foo) {
    *.py { echo "python" }
  }
   =====


(command.Case
  case_kw:<KW_Case case>
  to_match:(case_arg.YshExpr e:(Var foo))
  arms_start:<Lit_LBrace "{">
  arms:[
    (CaseArm
      left:<Lit_Star "*">
      pattern:(pat.Words words:[(w <Lit_Star "*"> <Lit_Chars .py>)])
      middle:<Lit_LBrace "{">
      action:[(C (w <Lit_Chars echo>) (w (DQ <Lit_Chars python>)))]
      right:<Lit_RBrace "}">
    )
  ]
  arms_end:<Lit_RBrace "}">
)

===== CASE: -n -c 
  case (foo) {
    (obj.attr) { echo "python" }
  }
   =====


(command.Case
  case_kw:<KW_Case case>
  to_match:(case_arg.YshExpr e:(Var foo))
  arms_start:<Lit_LBrace "{">
  arms:[
    (CaseArm
      left:<Op_LParen "(">
      pattern:(pat.YshExprs
        exprs:[
          (Attribute
            obj:(Var obj)
            op:<Expr_Dot .>
            attr:<Expr_Name attr>
            attr_name:attr
            ctx:expr_context.Store
          )
        ]
      )
      middle:<Lit_LBrace "{">
      action:[(C (w <Lit_Chars echo>) (w (DQ <Lit_Chars python>)))]
      right:<Lit_RBrace "}">
    )
  ]
  arms_end:<Lit_RBrace "}">
)

===== CASE: -n -c 
  case (foo) {
    (0) { echo "python" }
  }
   =====


(command.Case
  case_kw:<KW_Case case>
  to_match:(case_arg.YshExpr e:(Var foo))
  arms_start:<Lit_LBrace "{">
  arms:[
    (CaseArm
      left:<Op_LParen "(">
      pattern:(pat.YshExprs exprs:[(Const Expr_DecInt _)])
      middle:<Lit_LBrace "{">
      action:[(C (w <Lit_Chars echo>) (w (DQ <Lit_Chars python>)))]
      right:<Lit_RBrace "}">
    )
  ]
  arms_end:<Lit_RBrace "}">
)

===== CASE: -n -c 
  case (foo) {
    ("main.py") { echo "python" }
  }
   =====


(command.Case
  case_kw:<KW_Case case>
  to_match:(case_arg.YshExpr e:(Var foo))
  arms_start:<Lit_LBrace "{">
  arms:[
    (CaseArm
      left:<Op_LParen "(">
      pattern:(pat.YshExprs exprs:[(DQ <Lit_Chars main.py>)])
      middle:<Lit_LBrace "{">
      action:[(C (w <Lit_Chars echo>) (w (DQ <Lit_Chars python>)))]
      right:<Lit_RBrace "}">
    )
  ]
  arms_end:<Lit_RBrace "}">
)

===== CASE: -n -c 
  case (foo) { ("main.py") { echo "python" } }
   =====


(command.Case
  case_kw:<KW_Case case>
  to_match:(case_arg.YshExpr e:(Var foo))
  arms_start:<Lit_LBrace "{">
  arms:[
    (CaseArm
      left:<Op_LParen "(">
      pattern:(pat.YshExprs exprs:[(DQ <Lit_Chars main.py>)])
      middle:<Lit_LBrace "{">
      action:[(C (w <Lit_Chars echo>) (w (DQ <Lit_Chars python>)))]
      right:<Lit_RBrace "}">
    )
  ]
  arms_end:<Lit_RBrace "}">
)

===== CASE: -n -c 
  case (foo) {
    ("main.py") {
      echo "python" } } =====


(command.Case
  case_kw:<KW_Case case>
  to_match:(case_arg.YshExpr e:(Var foo))
  arms_start:<Lit_LBrace "{">
  arms:[
    (CaseArm
      left:<Op_LParen "(">
      pattern:(pat.YshExprs exprs:[(DQ <Lit_Chars main.py>)])
      middle:<Lit_LBrace "{">
      action:[(C (w <Lit_Chars echo>) (w (DQ <Lit_Chars python>)))]
      right:<Lit_RBrace "}">
    )
  ]
  arms_end:<Lit_RBrace "}">
)

===== CASE: -n -c 
  case (foo) {
    ("main.py") {
      echo "python" }
  }
   =====


(command.Case
  case_kw:<KW_Case case>
  to_match:(case_arg.YshExpr e:(Var foo))
  arms_start:<Lit_LBrace "{">
  arms:[
    (CaseArm
      left:<Op_LParen "(">
      pattern:(pat.YshExprs exprs:[(DQ <Lit_Chars main.py>)])
      middle:<Lit_LBrace "{">
      action:[(C (w <Lit_Chars echo>) (w (DQ <Lit_Chars python>)))]
      right:<Lit_RBrace "}">
    )
  ]
  arms_end:<Lit_RBrace "}">
)

===== CASE: -n -c 
  case (foo) {
    ("main.py") { echo "python"
    }
  }
   =====


(command.Case
  case_kw:<KW_Case case>
  to_match:(case_arg.YshExpr e:(Var foo))
  arms_start:<Lit_LBrace "{">
  arms:[
    (CaseArm
      left:<Op_LParen "(">
      pattern:(pat.YshExprs exprs:[(DQ <Lit_Chars main.py>)])
      middle:<Lit_LBrace "{">
      action:[(C (w <Lit_Chars echo>) (w (DQ <Lit_Chars python>)))]
      right:<Lit_RBrace "}">
    )
  ]
  arms_end:<Lit_RBrace "}">
)

===== CASE: -n -c 
  case (foo) {
    ("main.py") {
      echo "python"
    }
  }
   =====


(command.Case
  case_kw:<KW_Case case>
  to_match:(case_arg.YshExpr e:(Var foo))
  arms_start:<Lit_LBrace "{">
  arms:[
    (CaseArm
      left:<Op_LParen "(">
      pattern:(pat.YshExprs exprs:[(DQ <Lit_Chars main.py>)])
      middle:<Lit_LBrace "{">
      action:[(C (w <Lit_Chars echo>) (w (DQ <Lit_Chars python>)))]
      right:<Lit_RBrace "}">
    )
  ]
  arms_end:<Lit_RBrace "}">
)

===== CASE: -n -c 
  case (add(10, 32)) {
    (40 + 2) { echo Found the answer }
    (else) { echo Incorrect
    }
  }
   =====


(command.Case
  case_kw:<KW_Case case>
  to_match:(case_arg.YshExpr
    e:(expr.FuncCall
      func:(Var add)
      args:(ArgList
        left:<Op_LParen "(">
        pos_args:[(Const Expr_DecInt _) (Const Expr_DecInt _)]
        named_args:[]
        right:<Op_RParen ")">
      )
    )
  )
  arms_start:<Lit_LBrace "{">
  arms:[
    (CaseArm
      left:<Op_LParen "(">
      pattern:(pat.YshExprs
        exprs:[
          (expr.Binary
            op:<Arith_Plus "+">
            left:(Const Expr_DecInt _)
            right:(Const Expr_DecInt _)
          )
        ]
      )
      middle:<Lit_LBrace "{">
      action:[
        (C
          (w <Lit_Chars echo>)
          (w <Lit_Chars Found>)
          (w <Lit_Chars the>)
          (w <Lit_Chars answer>)
        )
      ]
      right:<Lit_RBrace "}">
    )
    (CaseArm
      left:<Op_LParen "(">
      pattern:(pat.Else)
      middle:<Lit_LBrace "{">
      action:[(C (w <Lit_Chars echo>) (w <Lit_Chars Incorrect>))]
      right:<Lit_RBrace "}">
    )
  ]
  arms_end:<Lit_RBrace "}">
)

===== CASE: -n -c 
  case (file) {
    / dot* '.py' / {
      echo Python
    }

    / dot* ('.cc' | '.h') /
    {
      echo C++
    }
  }
   =====


(command.Case
  case_kw:<KW_Case case>
  to_match:(case_arg.YshExpr e:(Var file))
  arms_start:<Lit_LBrace "{">
  arms:[
    (CaseArm
      left:<Arith_Slash />
      pattern:(Eggex
        left:...0x7f2ca20ce668
        regex:(re.Seq
          children:[
            (re.Repeat
              child:(re.Primitive blame_tok:<Expr_Name dot> id:Eggex_Dot)
              op:<Arith_Star "*">
            )
            (SQ .py)
          ]
        )
        flags:[]
        canonical_flags:""
      )
      middle:<Lit_LBrace "{">
      action:[(C (w <Lit_Chars echo>) (w <Lit_Chars Python>))]
      right:<Lit_RBrace "}">
    )
    (CaseArm
      left:<Arith_Slash />
      pattern:(Eggex
        left:...0x7f2ca20cec80
        regex:(re.Seq
          children:[
            (re.Repeat
              child:(re.Primitive blame_tok:<Expr_Name dot> id:Eggex_Dot)
              op:<Arith_Star "*">
            )
            (re.Group child:(re.Alt children:[(SQ .cc) (SQ .h)]))
          ]
        )
        flags:[]
        canonical_flags:""
      )
      middle:<Lit_LBrace "{">
      action:[
        (C
          (w <Lit_Chars echo>)
          (w <Lit_Chars C> <Lit_Other "+"> <Lit_Other "+">)
        )
      ]
      right:<Lit_RBrace "}">
    )
  ]
  arms_end:<Lit_RBrace "}">
)

===== CASE: -n -c 
  case (lang) {
      en-US
    | en-CA
    | en-UK {
      echo Hello
    }
    fr-FR |
    fr-CA {
      echo Bonjour
    }





    (else) {
      echo o/
    }
  }
   =====


(command.Case
  case_kw:<KW_Case case>
  to_match:(case_arg.YshExpr e:(Var lang))
  arms_start:<Lit_LBrace "{">
  arms:[
    (CaseArm
      left:<Lit_Chars en-US>
      pattern:(pat.Words
        words:[
          (w <Lit_Chars en-US>) (w <Lit_Chars en-CA>) (w <Lit_Chars en-UK>)
        ]
      )
      middle:<Lit_LBrace "{">
      action:[(C (w <Lit_Chars echo>) (w <Lit_Chars Hello>))]
      right:<Lit_RBrace "}">
    )
    (CaseArm
      left:<Lit_Chars fr-FR>
      pattern:(pat.Words words:[(w <Lit_Chars fr-FR>) (w <Lit_Chars fr-CA>)])
      middle:<Lit_LBrace "{">
      action:[(C (w <Lit_Chars echo>) (w <Lit_Chars Bonjour>))]
      right:<Lit_RBrace "}">
    )
    (CaseArm
      left:<Op_LParen "(">
      pattern:(pat.Else)
      middle:<Lit_LBrace "{">
      action:[(C (w <Lit_Chars echo>) (w <Lit_Chars o> <Lit_Slash />))]
      right:<Lit_RBrace "}">
    )
  ]
  arms_end:<Lit_RBrace "}">
)

===== CASE: -n -c 
  case (num) {
    (1) | (2) {
      echo number
    }
  }
   =====


(command.Case
  case_kw:<KW_Case case>
  to_match:(case_arg.YshExpr e:(Var num))
  arms_start:<Lit_LBrace "{">
  arms:[
    (CaseArm
      left:<Op_LParen "(">
      pattern:(pat.YshExprs exprs:[(Const Expr_DecInt _) (Const Expr_DecInt _)])
      middle:<Lit_LBrace "{">
      action:[(C (w <Lit_Chars echo>) (w <Lit_Chars number>))]
      right:<Lit_RBrace "}">
    )
  ]
  arms_end:<Lit_RBrace "}">
)

===== CASE: -n -c 
  case (num) {
      (1) | (2) | (3)
    | (4) | (5) {
      echo small
    }

    (else) {
      echo large
    }
  }
   =====


(command.Case
  case_kw:<KW_Case case>
  to_match:(case_arg.YshExpr e:(Var num))
  arms_start:<Lit_LBrace "{">
  arms:[
    (CaseArm
      left:<Op_LParen "(">
      pattern:(pat.YshExprs
        exprs:[
          (Const Expr_DecInt _) (Const Expr_DecInt _) (Const Expr_DecInt _)
          (Const Expr_DecInt _) (Const Expr_DecInt _)
        ]
      )
      middle:<Lit_LBrace "{">
      action:[(C (w <Lit_Chars echo>) (w <Lit_Chars small>))]
      right:<Lit_RBrace "}">
    )
    (CaseArm
      left:<Op_LParen "(">
      pattern:(pat.Else)
      middle:<Lit_LBrace "{">
      action:[(C (w <Lit_Chars echo>) (w <Lit_Chars large>))]
      right:<Lit_RBrace "}">
    )
  ]
  arms_end:<Lit_RBrace "}">
)

===== CASE: -n -c 
  case
  (add(10, 32)) {
      (40 + 2) { echo Found the answer }
      (else) { echo Incorrect }
  }
   =====


    case
        ^
[ -c flag ]:2: Expected a word to match against

===== CASE: -n -c 
  case (file)
  {
    ('README') | / dot* '.md' / { echo Markdown }
  }
   =====


    case (file)
               ^
[ -c flag ]:2: Expected word type Id.Lit_LBrace, got Id.Op_Newline

===== CASE: -n -c 
  case (file)
  {
    {
      echo Python
    }
  }
   =====


    case (file)
               ^
[ -c flag ]:2: Expected word type Id.Lit_LBrace, got Id.Op_Newline

===== CASE: -n -c 
  case (file)
  {
    cc h {
      echo C++
    }
  }
   =====


    case (file)
               ^
[ -c flag ]:2: Expected word type Id.Lit_LBrace, got Id.Op_Newline

===== CASE: -n -c 
  case (lang) {
      en-US
    | ('en-CA')
    | / 'en-UK' / {
      echo Hello
    }
  }
   =====


      | ('en-CA')
        ^
[ -c flag ]:4: Expected case pattern

===== CASE: -n -c 
  case (lang) {
    else) {
      echo o/
    }
  }
   =====


      else) {
          ^
[ -c flag ]:3: Expected word type Id.Lit_LBrace, got Id.Op_RParen

===== CASE: -n -c 
  case (num) {
      (1) | (2) | (3)
    | (4) | (5) {
      echo small
    }

    (6) | (else) {
      echo large
    }
  }
   =====


      (6) | (else) {
             ^~~~
[ -c flag ]:8: Syntax error in expression (near Id.Expr_Else)

===== CASE: -n -c 
  case $foo {
    ("main.py") {
      echo "python"
    }
  }
   =====


    case $foo {
              ^
[ -c flag ]:2: Expected word type Id.KW_In, got Id.Lit_LBrace

===== CASE: -n -c 
  case (x)
  {
    *.py { echo "python" }
  }
   =====


    case (x)
            ^
[ -c flag ]:2: Expected word type Id.Lit_LBrace, got Id.Op_Newline

===== CASE: -n -c 
  case (foo) in
    *.py {
      echo "python"
    }
  esac
   =====


    case (foo) in
               ^~
[ -c flag ]:2: Expected word type Id.Lit_LBrace, got Id.KW_In

===== CASE: -n -c 
  case $foo {
    bar) {
      echo "python"
    }
  }
   =====


    case $foo {
              ^
[ -c flag ]:2: Expected word type Id.KW_In, got Id.Lit_LBrace

===== CASE: -n -c 
  case (x) {
    {
      echo "python"
    }
  }
   =====


        echo "python"
        ^~~~
[ -c flag ]:4: Expected word type Id.Lit_LBrace, got Id.Word_Compound

===== CASE: -n -c 
  case (x {
    *.py { echo "python" }
  }
   =====


    case (x {
            ^
[ -c flag ]:2: Syntax error in expression (near Id.Op_LBrace)

===== CASE: -n -c 
  case (x) {
    *.py) { echo "python" }
  }
   =====


      *.py) { echo "python" }
          ^
[ -c flag ]:3: Expected word type Id.Lit_LBrace, got Id.Op_RParen

===== CASE: -n -c case (x) { word { echo word; } (3) { echo expr; } /'eggex'/ { echo eggex; } } =====


(command.Case
  case_kw:<KW_Case case>
  to_match:(case_arg.YshExpr e:(Var x))
  arms_start:<Lit_LBrace "{">
  arms:[
    (CaseArm
      left:<Lit_Chars word>
      pattern:(pat.Words words:[(w <Lit_Chars word>)])
      middle:<Lit_LBrace "{">
      action:[
        (command.Sentence
          child:(C (w <Lit_Chars echo>) (w <Lit_Chars word>))
          terminator:<Op_Semi ";">
        )
      ]
      right:<Lit_RBrace "}">
    )
    (CaseArm
      left:<Op_LParen "(">
      pattern:(pat.YshExprs exprs:[(Const Expr_DecInt _)])
      middle:<Lit_LBrace "{">
      action:[
        (command.Sentence
          child:(C (w <Lit_Chars echo>) (w <Lit_Chars expr>))
          terminator:<Op_Semi ";">
        )
      ]
      right:<Lit_RBrace "}">
    )
    (CaseArm
      left:<Arith_Slash />
      pattern:(Eggex
        left:...0x7f5ef7a83e20
        regex:(SQ eggex)
        flags:[]
        canonical_flags:""
      )
      middle:<Lit_LBrace "{">
      action:[
        (command.Sentence
          child:(C (w <Lit_Chars echo>) (w <Lit_Chars eggex>))
          terminator:<Op_Semi ";">
        )
      ]
      right:<Lit_RBrace "}">
    )
  ]
  arms_end:<Lit_RBrace "}">
)

===== CASE: -n -c 
case (x) {
  word    { echo word; } (3)     { echo expr; } /'eggex'/ { echo eggex; } } =====


(command.Case
  case_kw:<KW_Case case>
  to_match:(case_arg.YshExpr e:(Var x))
  arms_start:<Lit_LBrace "{">
  arms:[
    (CaseArm
      left:<Lit_Chars word>
      pattern:(pat.Words words:[(w <Lit_Chars word>)])
      middle:<Lit_LBrace "{">
      action:[
        (command.Sentence
          child:(C (w <Lit_Chars echo>) (w <Lit_Chars word>))
          terminator:<Op_Semi ";">
        )
      ]
      right:<Lit_RBrace "}">
    )
    (CaseArm
      left:<Op_LParen "(">
      pattern:(pat.YshExprs exprs:[(Const Expr_DecInt _)])
      middle:<Lit_LBrace "{">
      action:[
        (command.Sentence
          child:(C (w <Lit_Chars echo>) (w <Lit_Chars expr>))
          terminator:<Op_Semi ";">
        )
      ]
      right:<Lit_RBrace "}">
    )
    (CaseArm
      left:<Arith_Slash />
      pattern:(Eggex
        left:...0x7f40c9f59e20
        regex:(SQ eggex)
        flags:[]
        canonical_flags:""
      )
      middle:<Lit_LBrace "{">
      action:[
        (command.Sentence
          child:(C (w <Lit_Chars echo>) (w <Lit_Chars eggex>))
          terminator:<Op_Semi ";">
        )
      ]
      right:<Lit_RBrace "}">
    )
  ]
  arms_end:<Lit_RBrace "}">
)

===== CASE: -n -c 
case (x) {
  word    { echo word; }
  (3)     { echo expr; } /'eggex'/ { echo eggex; } } =====


(command.Case
  case_kw:<KW_Case case>
  to_match:(case_arg.YshExpr e:(Var x))
  arms_start:<Lit_LBrace "{">
  arms:[
    (CaseArm
      left:<Lit_Chars word>
      pattern:(pat.Words words:[(w <Lit_Chars word>)])
      middle:<Lit_LBrace "{">
      action:[
        (command.Sentence
          child:(C (w <Lit_Chars echo>) (w <Lit_Chars word>))
          terminator:<Op_Semi ";">
        )
      ]
      right:<Lit_RBrace "}">
    )
    (CaseArm
      left:<Op_LParen "(">
      pattern:(pat.YshExprs exprs:[(Const Expr_DecInt _)])
      middle:<Lit_LBrace "{">
      action:[
        (command.Sentence
          child:(C (w <Lit_Chars echo>) (w <Lit_Chars expr>))
          terminator:<Op_Semi ";">
        )
      ]
      right:<Lit_RBrace "}">
    )
    (CaseArm
      left:<Arith_Slash />
      pattern:(Eggex
        left:...0x7f3dfa5b3e20
        regex:(SQ eggex)
        flags:[]
        canonical_flags:""
      )
      middle:<Lit_LBrace "{">
      action:[
        (command.Sentence
          child:(C (w <Lit_Chars echo>) (w <Lit_Chars eggex>))
          terminator:<Op_Semi ";">
        )
      ]
      right:<Lit_RBrace "}">
    )
  ]
  arms_end:<Lit_RBrace "}">
)

===== CASE: -n -c 
case (x) {
  word    { echo word; }
  (3)     { echo expr; }
  /'eggex'/ { echo eggex; } } =====


(command.Case
  case_kw:<KW_Case case>
  to_match:(case_arg.YshExpr e:(Var x))
  arms_start:<Lit_LBrace "{">
  arms:[
    (CaseArm
      left:<Lit_Chars word>
      pattern:(pat.Words words:[(w <Lit_Chars word>)])
      middle:<Lit_LBrace "{">
      action:[
        (command.Sentence
          child:(C (w <Lit_Chars echo>) (w <Lit_Chars word>))
          terminator:<Op_Semi ";">
        )
      ]
      right:<Lit_RBrace "}">
    )
    (CaseArm
      left:<Op_LParen "(">
      pattern:(pat.YshExprs exprs:[(Const Expr_DecInt _)])
      middle:<Lit_LBrace "{">
      action:[
        (command.Sentence
          child:(C (w <Lit_Chars echo>) (w <Lit_Chars expr>))
          terminator:<Op_Semi ";">
        )
      ]
      right:<Lit_RBrace "}">
    )
    (CaseArm
      left:<Arith_Slash />
      pattern:(Eggex
        left:...0x7fad4532be20
        regex:(SQ eggex)
        flags:[]
        canonical_flags:""
      )
      middle:<Lit_LBrace "{">
      action:[
        (command.Sentence
          child:(C (w <Lit_Chars echo>) (w <Lit_Chars eggex>))
          terminator:<Op_Semi ";">
        )
      ]
      right:<Lit_RBrace "}">
    )
  ]
  arms_end:<Lit_RBrace "}">
)

===== CASE: -n -c 
case (x) {
  word    { echo word; }
  (3)     { echo expr; }
  /'eggex'/ { echo eggex; }
} =====


(command.Case
  case_kw:<KW_Case case>
  to_match:(case_arg.YshExpr e:(Var x))
  arms_start:<Lit_LBrace "{">
  arms:[
    (CaseArm
      left:<Lit_Chars word>
      pattern:(pat.Words words:[(w <Lit_Chars word>)])
      middle:<Lit_LBrace "{">
      action:[
        (command.Sentence
          child:(C (w <Lit_Chars echo>) (w <Lit_Chars word>))
          terminator:<Op_Semi ";">
        )
      ]
      right:<Lit_RBrace "}">
    )
    (CaseArm
      left:<Op_LParen "(">
      pattern:(pat.YshExprs exprs:[(Const Expr_DecInt _)])
      middle:<Lit_LBrace "{">
      action:[
        (command.Sentence
          child:(C (w <Lit_Chars echo>) (w <Lit_Chars expr>))
          terminator:<Op_Semi ";">
        )
      ]
      right:<Lit_RBrace "}">
    )
    (CaseArm
      left:<Arith_Slash />
      pattern:(Eggex
        left:...0x7fe54563ae20
        regex:(SQ eggex)
        flags:[]
        canonical_flags:""
      )
      middle:<Lit_LBrace "{">
      action:[
        (command.Sentence
          child:(C (w <Lit_Chars echo>) (w <Lit_Chars eggex>))
          terminator:<Op_Semi ";">
        )
      ]
      right:<Lit_RBrace "}">
    )
  ]
  arms_end:<Lit_RBrace "}">
)

===== CASE: -n -c 
case (x) {
word    { echo word; }
(3)     { echo expr; }
/'eggex'/ { echo eggex; }
} =====


(command.Case
  case_kw:<KW_Case case>
  to_match:(case_arg.YshExpr e:(Var x))
  arms_start:<Lit_LBrace "{">
  arms:[
    (CaseArm
      left:<Lit_Chars word>
      pattern:(pat.Words words:[(w <Lit_Chars word>)])
      middle:<Lit_LBrace "{">
      action:[
        (command.Sentence
          child:(C (w <Lit_Chars echo>) (w <Lit_Chars word>))
          terminator:<Op_Semi ";">
        )
      ]
      right:<Lit_RBrace "}">
    )
    (CaseArm
      left:<Op_LParen "(">
      pattern:(pat.YshExprs exprs:[(Const Expr_DecInt _)])
      middle:<Lit_LBrace "{">
      action:[
        (command.Sentence
          child:(C (w <Lit_Chars echo>) (w <Lit_Chars expr>))
          terminator:<Op_Semi ";">
        )
      ]
      right:<Lit_RBrace "}">
    )
    (CaseArm
      left:<Arith_Slash />
      pattern:(Eggex
        left:...0x7f4606e50e20
        regex:(SQ eggex)
        flags:[]
        canonical_flags:""
      )
      middle:<Lit_LBrace "{">
      action:[
        (command.Sentence
          child:(C (w <Lit_Chars echo>) (w <Lit_Chars eggex>))
          terminator:<Op_Semi ";">
        )
      ]
      right:<Lit_RBrace "}">
    )
  ]
  arms_end:<Lit_RBrace "}">
)
OK  test-ysh-case
*** Running test-ysh-expr

===== CASE: -n -c = 5 mod 3 =====


  = 5 mod 3
          ^
[ -c flag ]:1: Syntax error in expression (near Id.Expr_DecInt)

===== CASE: -n -c = >>= =====


  = >>=
    ^~~
[ -c flag ]:1: Syntax error in expression (near Id.Arith_DGreatEqual)

===== CASE: -n -c = %( =====


  = %(
      ^
[ -c flag ]:1: Unexpected token in array literal

===== CASE: -n -c = 42, =====


  = 42,
      ^
[ -c flag ]:1: Invalid trailing comma

===== CASE: -n -c = (42,) =====


  = (42,)
       ^
[ -c flag ]:1: Invalid trailing comma

===== CASE: -n -c =a =====


  =a
  ^
[ -c flag ]:1: =word isn't allowed.  Hint: add a space after =, or quote it
OK  test-ysh-expr
*** Running test-ysh-expr-more

===== CASE: -n -c if (5 == 5) { echo yes } =====


  if (5 == 5) { echo yes }
        ^~
[ -c flag ]:1: Use === to be exact, or ~== to convert types

===== CASE: -n -c echo $[join(x)] =====


(C
  (w <Lit_Chars echo>)
  (w
    (word_part.ExprSub
      left:<Left_DollarBracket "$[">
      child:(expr.FuncCall
        func:(Var join)
        args:(ArgList
          left:<Op_LParen "(">
          pos_args:[(Var x)]
          named_args:[]
          right:<Op_RParen ")">
        )
      )
      right:<Op_RBracket "]">
    )
  )
)

===== CASE: -n -c echo $join(x) =====


  echo $join(x)
            ^
[ -c flag ]:1: Space required before (

===== CASE: -n -c echo @[split(x)] =====


(C
  (w <Lit_Chars echo>)
  (w
    (word_part.ExprSub
      left:<Lit_AtLBracket "@[">
      child:(expr.FuncCall
        func:(Var split)
        args:(ArgList
          left:<Op_LParen "(">
          pos_args:[(Var x)]
          named_args:[]
          right:<Op_RParen ")">
        )
      )
      right:<Op_RBracket "]">
    )
  )
)

===== CASE: -n -c echo @[split(x)] two =====


(C
  (w <Lit_Chars echo>)
  (w
    (word_part.ExprSub
      left:<Lit_AtLBracket "@[">
      child:(expr.FuncCall
        func:(Var split)
        args:(ArgList
          left:<Op_LParen "(">
          pos_args:[(Var x)]
          named_args:[]
          right:<Op_RParen ")">
        )
      )
      right:<Op_RBracket "]">
    )
  )
  (w <Lit_Chars two>)
)

===== CASE: -n -c echo @[split(x)]extra =====


  echo @[split(x)]extra
                  ^~~~~
[ -c flag ]:1: Unexpected token after Expr splice

===== CASE: -n -c echo @split("a") =====


  echo @split("a")
             ^
[ -c flag ]:1: Space required before (
OK  test-ysh-expr-more
*** Running test-ysh-for

===== CASE: -n -c 
  for x in (obj) {
    echo $x
  }
   =====


(command.ForEach
  keyword:<KW_For for>
  iter_names:[x]
  iterable:(for_iter.YshExpr e:(Var obj) blame:<KW_In in>)
  body:(BraceGroup
    left:<Lit_LBrace "{">
    children:[(C (w <Lit_Chars echo>) (w ($ x)))]
    right:<Lit_RBrace "}">
  )
)

===== CASE: -n -c 
  for x in (obj); do
    echo $x
  done
   =====


    for x in (obj); do
                  ^
[ -c flag ]:2: Expected { after iterable expression

===== CASE: -n -c 
  for x, y in SPAM EGGS; do
    echo $x
  done
   =====


(command.ForEach
  keyword:<KW_For for>
  iter_names:[x y]
  iterable:(for_iter.Words words:[(w <Lit_Chars SPAM>) (w <Lit_Chars EGGS>)])
  semi_tok:<Op_Semi ";">
  body:(command.DoGroup
    left:<KW_Do do>
    children:[(C (w <Lit_Chars echo>) (w ($ x)))]
    right:<KW_Done done>
  )
)

===== CASE: -n -c 
  for x-y in SPAM EGGS; do
    echo $x
  done
   =====


    for x-y in SPAM EGGS; do
        ^~~
[ -c flag ]:2: Invalid loop variable name 'x-y'

===== CASE: -n -c 
  for x, y, z in SPAM EGGS; do
    echo $x
  done
   =====


    for x, y, z in SPAM EGGS; do
    ^~~
[ -c flag ]:2: Expected at most 2 loop variables

===== CASE: -n -c 
  for w, x, y, z in SPAM EGGS; do
    echo $x
  done
   =====


    for w, x, y, z in SPAM EGGS; do
                 ^
[ -c flag ]:2: Unexpected word after 3 loop variables

===== CASE: -n -c 
  for x, y in SPAM EGGS
  do
    echo $x
  done
   =====


(command.ForEach
  keyword:<KW_For for>
  iter_names:[x y]
  iterable:(for_iter.Words words:[(w <Lit_Chars SPAM>) (w <Lit_Chars EGGS>)])
  body:(command.DoGroup
    left:<KW_Do do>
    children:[(C (w <Lit_Chars echo>) (w ($ x)))]
    right:<KW_Done done>
  )
)

===== CASE: -n -c for const in (x) { echo $var } =====


(command.ForEach
  keyword:<KW_For for>
  iter_names:[const]
  iterable:(for_iter.YshExpr e:(Var x) blame:<KW_In in>)
  body:(BraceGroup
    left:<Lit_LBrace "{">
    children:[(C (w <Lit_Chars echo>) (w ($ var)))]
    right:<Lit_RBrace "}">
  )
)
OK  test-ysh-for
*** Running test-ysh-nested-proc-func

===== CASE: -n -c proc p { echo 1; proc f { echo f }; echo 2 } =====


(Proc
  keyword:<KW_Proc proc>
  name:<Lit_Chars p>
  sig:(proc_sig.Open)
  body:(BraceGroup
    left:<Lit_LBrace "{">
    children:[
      (command.Sentence
        child:(C (w <Lit_Chars echo>) (w <Lit_Chars 1>))
        terminator:<Op_Semi ";">
      )
      (command.Sentence
        child:(Proc
          keyword:<KW_Proc proc>
          name:<Lit_Chars f>
          sig:...0x7f0a3d7e3510
          body:(BraceGroup
            left:<Lit_LBrace "{">
            children:[(C (w <Lit_Chars echo>) (w <Lit_Chars f>))]
            right:<Lit_RBrace "}">
          )
        )
        terminator:<Op_Semi ";">
      )
      (C (w <Lit_Chars echo>) (w <Lit_Chars 2>))
    ]
    right:<Lit_RBrace "}">
  )
)

===== CASE: -n -c func f() { echo 1; proc f { echo f }; echo 2 } =====


(Func
  keyword:<KW_Func func>
  name:<Expr_Name f>
  body:(BraceGroup
    left:<Lit_LBrace "{">
    children:[
      (command.Sentence
        child:(C (w <Lit_Chars echo>) (w <Lit_Chars 1>))
        terminator:<Op_Semi ";">
      )
      (command.Sentence
        child:(Proc
          keyword:<KW_Proc proc>
          name:<Lit_Chars f>
          sig:(proc_sig.Open)
          body:(BraceGroup
            left:<Lit_LBrace "{">
            children:[(C (w <Lit_Chars echo>) (w <Lit_Chars f>))]
            right:<Lit_RBrace "}">
          )
        )
        terminator:<Op_Semi ";">
      )
      (C (w <Lit_Chars echo>) (w <Lit_Chars 2>))
    ]
    right:<Lit_RBrace "}">
  )
)

===== CASE: -n -c proc p { echo 1; func f() { echo f }; echo 2 } =====


(Proc
  keyword:<KW_Proc proc>
  name:<Lit_Chars p>
  sig:(proc_sig.Open)
  body:(BraceGroup
    left:<Lit_LBrace "{">
    children:[
      (command.Sentence
        child:(C (w <Lit_Chars echo>) (w <Lit_Chars 1>))
        terminator:<Op_Semi ";">
      )
      (command.Sentence
        child:(Func
          keyword:<KW_Func func>
          name:<Expr_Name f>
          body:(BraceGroup
            left:<Lit_LBrace "{">
            children:[(C (w <Lit_Chars echo>) (w <Lit_Chars f>))]
            right:<Lit_RBrace "}">
          )
        )
        terminator:<Op_Semi ";">
      )
      (C (w <Lit_Chars echo>) (w <Lit_Chars 2>))
    ]
    right:<Lit_RBrace "}">
  )
)

===== CASE: -n -c func f() { echo 1; func f2() { echo f }; echo 2 } =====


(Func
  keyword:<KW_Func func>
  name:<Expr_Name f>
  body:(BraceGroup
    left:<Lit_LBrace "{">
    children:[
      (command.Sentence
        child:(C (w <Lit_Chars echo>) (w <Lit_Chars 1>))
        terminator:<Op_Semi ";">
      )
      (command.Sentence
        child:(Func
          keyword:<KW_Func func>
          name:<Expr_Name f2>
          body:(BraceGroup
            left:<Lit_LBrace "{">
            children:[(C (w <Lit_Chars echo>) (w <Lit_Chars f>))]
            right:<Lit_RBrace "}">
          )
        )
        terminator:<Op_Semi ";">
      )
      (C (w <Lit_Chars echo>) (w <Lit_Chars 2>))
    ]
    right:<Lit_RBrace "}">
  )
)

===== CASE: -n -c proc p { echo 1; +weird() { echo f; }; echo 2 } =====


  proc p { echo 1; +weird() { echo f; }; echo 2 }
                   ^
[ -c flag ]:1: shell functions can't be defined inside proc or func

===== CASE: -n -c proc p { echo 1; function f { echo f; }; echo 2 } =====


  proc p { echo 1; function f { echo f; }; echo 2 }
                   ^~~~~~~~
[ -c flag ]:1: shell functions can't be defined inside proc or func

===== CASE: -n -c func outer() { function f { echo f } } =====


  func outer() { function f { echo f } }
                 ^~~~~~~~
[ -c flag ]:1: shell functions can't be defined inside proc or func

===== CASE: -n -c f() { echo 1; proc inner { echo inner; }; echo 2; } =====


  f() { echo 1; proc inner { echo inner; }; echo 2; }
                ^~~~
[ -c flag ]:1: procs can't be defined inside shell functions

===== CASE: -n -c f() { func inner() { var a = 1 } } =====


  f() { func inner() { var a = 1 } }
        ^~~~
[ -c flag ]:1: funcs can't be defined inside shell functions

===== CASE: -n -c f() { echo 1; g() { echo g; }; echo 2; } =====


(command.ShFunction
  name_tok:<Lit_Chars f>
  name:f
  body:(BraceGroup
    left:<Lit_LBrace "{">
    children:[
      (command.Sentence
        child:(C (w <Lit_Chars echo>) (w <Lit_Chars 1>))
        terminator:<Op_Semi ";">
      )
      (command.Sentence
        child:(command.ShFunction
          name_tok:<Lit_Chars g>
          name:g
          body:(BraceGroup
            left:<Lit_LBrace "{">
            children:[
              (command.Sentence
                child:(C (w <Lit_Chars echo>) (w <Lit_Chars g>))
                terminator:<Op_Semi ";">
              )
            ]
            right:<Lit_RBrace "}">
          )
        )
        terminator:<Op_Semi ";">
      )
      (command.Sentence
        child:(C (w <Lit_Chars echo>) (w <Lit_Chars 2>))
        terminator:<Op_Semi ";">
      )
    ]
    right:<Lit_RBrace "}">
  )
)

===== CASE: -n -c proc p() { shopt --unset errexit { false hi } } =====


(Proc
  keyword:<KW_Proc proc>
  name:<Lit_Chars p>
  sig:(proc_sig.Closed)
  body:(BraceGroup
    left:<Lit_LBrace "{">
    children:[
      (command.Simple
        blame_tok:<Lit_Chars shopt>
        more_env:[]
        words:[
          (w <Lit_Chars shopt>)
          (w <Lit_Chars --unset>)
          (w <Lit_Chars errexit>)
        ]
        block:(LiteralBlock
          brace_group:(BraceGroup
            left:<Lit_LBrace "{">
            children:[(C (w <Lit_Chars "false">) (w <Lit_Chars hi>))]
            right:<Lit_RBrace "}">
          )
          lines:[
            (SourceLine
              line_num:1
              content:"proc p() { shopt --unset errexit { false hi } }"
              src:(source.CFlag)
            )
          ]
        )
        is_last_cmd:F
      )
    ]
    right:<Lit_RBrace "}">
  )
)
OK  test-ysh-nested-proc-func
*** Running test-ysh-var

===== CASE: -n -c var x = 1 +  =====


  var x = 1 +
              ^
[ -c flag ]:1: Syntax error in expression (near Id.Eof_Real)

===== CASE: -n -c var x = *  =====


  var x = *
          ^
[ -c flag ]:1: Syntax error in expression (near Id.Arith_Star)

===== CASE: -n -c var x = @($(cat <<EOF
here doc
EOF
)) =====


  var x = @($(cat <<EOF
          ^~
[ -c flag ]:1: Here docs aren't allowed in expressions

===== CASE: -n -c var x = $(var x = 1; ) =====


(command.VarDecl
  keyword:<KW_Var var>
  lhs:[(NameType left:<Expr_Name x> name:x)]
  rhs:(CommandSub
    left_token:<Left_DollarParen "$(">
    child:(command.Sentence
      child:(command.VarDecl
        keyword:<KW_Var var>
        lhs:[(NameType left:<Expr_Name x> name:x)]
        rhs:(Const Expr_DecInt _)
      )
      terminator:<Op_Semi ";">
    )
    right:<Eof_RParen ")">
  )
)

===== CASE: -n -c 
  var x = $(var x = 1
) =====


(command.VarDecl
  keyword:<KW_Var var>
  lhs:[(NameType left:<Expr_Name x> name:x)]
  rhs:(CommandSub
    left_token:<Left_DollarParen "$(">
    child:(command.VarDecl
      keyword:<KW_Var var>
      lhs:[(NameType left:<Expr_Name x> name:x)]
      rhs:(Const Expr_DecInt _)
    )
    right:<Eof_RParen ")">
  )
)

===== CASE: -n -c var x = $(var x = 1) =====


  var x = $(var x = 1)
                     ^
[ -c flag ]:1: Syntax error in expression (near Id.Eof_RParen)

===== CASE: -n -c var x = $(var x = 1; )) =====


  var x = $(var x = 1; ))
                        ^
[ -c flag ]:1: Syntax error in expression (near Id.Op_RParen)

===== CASE: -n -c var x = $(var x = 1; ) ) =====


  var x = $(var x = 1; ) )
                         ^
[ -c flag ]:1: Syntax error in expression (near Id.Op_RParen)
OK  test-ysh-var
*** Running test-ysh_bare_words

===== CASE: -n -c echo \$ =====


(C
  (w <Lit_Chars echo>)
  (w (word_part.EscapedLiteral token:<Lit_EscapedChar "\\$"> ch:"$"))
)

===== CASE: -n -c echo \z =====


  echo \z
       ^~
[ -c flag ]:1: Invalid char escape in unquoted word (OILS-ERR-13)
OK  test-ysh_bare_words
*** Running test-ysh_c_strings

===== CASE: -n -c echo $'\u03bc' =====


(C
  (w <Lit_Chars echo>)
  (w
    (SingleQuoted
      left:<Left_DollarSingleQuote "$'">
      sval:"μ"
      right:<Right_SingleQuote "'">
    )
  )
)

===== CASE: -n -c echo $'\u{03bc}' =====


  echo $'\u{03bc}'
         ^
[ -c flag ]:1: Invalid char escape in C-style string literal (OILS-ERR-11)

===== CASE: -n -c echo $'\u{03bc' =====


  echo $'\u{03bc'
         ^
[ -c flag ]:1: Invalid char escape in C-style string literal (OILS-ERR-11)

===== CASE: -n -c const bad = $'\u{03bc' =====


  const bad = $'\u{03bc'
                ^
[ -c flag ]:1: Invalid char escape in C-style string literal (OILS-ERR-11)

===== CASE: -n -c echo $'\z' =====


(C
  (w <Lit_Chars echo>)
  (w
    (SingleQuoted
      left:<Left_DollarSingleQuote "$'">
      sval:"\\z"
      right:<Right_SingleQuote "'">
    )
  )
)

===== CASE: -n -c echo $'\z' =====


  echo $'\z'
         ^
[ -c flag ]:1: Invalid char escape in C-style string literal (OILS-ERR-11)

===== CASE: -n -c const bad = $'\z' =====


  const bad = $'\z'
                ^
[ -c flag ]:1: Invalid char escape in C-style string literal (OILS-ERR-11)

===== CASE: -n -c echo $'\101' =====


(C
  (w <Lit_Chars echo>)
  (w
    (SingleQuoted
      left:<Left_DollarSingleQuote "$'">
      sval:A
      right:<Right_SingleQuote "'">
    )
  )
)

===== CASE: -n -c const bad = $'\101' =====


  const bad = $'\101'
                ^~~~
[ -c flag ]:1: Use \xhh or \u{...} instead of octal escapes in YSH strings

===== CASE: -n -c const bad = c'\xf' =====


  const bad = c'\xf'
               ^
[ -c flag ]:1: Syntax error in expression (near Id.Left_SingleQuote)
OK  test-ysh_c_strings
*** Running test-ysh_dq_strings

===== CASE: -n -c echo "\z" =====


(C (w <Lit_Chars echo>) (w (DQ <Lit_BadBackslash "\\"> <Lit_Chars z>)))

===== CASE: +O parse_backslash -n -c echo test-parse_backslash "\z" =====


  echo test-parse_backslash "\z"
                             ^
[ -c flag ]:1: Invalid char escape in double quoted string (OILS-ERR-12)

===== CASE: -n -c echo "\z" =====


  echo "\z"
        ^
[ -c flag ]:1: Invalid char escape in double quoted string (OILS-ERR-12)

===== CASE: -n -c const bad = "\z" =====


  const bad = "\z"
               ^
[ -c flag ]:1: Invalid char escape in double quoted string (OILS-ERR-12)

===== CASE: -n -c echo "\u1234" =====


(C (w <Lit_Chars echo>) (w (DQ <Lit_BadBackslash "\\"> <Lit_Chars u1234>)))

===== CASE: -n -c echo "\u1234" =====


  echo "\u1234"
        ^
[ -c flag ]:1: Invalid char escape in double quoted string (OILS-ERR-12)

===== CASE: -n -c const bad = "\u1234" =====


  const bad = "\u1234"
               ^
[ -c flag ]:1: Invalid char escape in double quoted string (OILS-ERR-12)

===== CASE: -n -c echo "`echo hi`" =====


(C
  (w <Lit_Chars echo>)
  (w
    (DQ
      (CommandSub
        left_token:<Left_Backtick "`">
        child:(C (w <Lit_Chars echo>) (w <Lit_Chars hi>))
        right:<Backtick_Right "`">
      )
    )
  )
)

===== CASE: -n -c echo "`echo hi`" =====


  echo "`echo hi`"
        ^
[ -c flag ]:1: Use $(cmd) instead of backticks (parse_backticks)

===== CASE: -n -c const bad = "`echo hi`" =====


  const bad = "`echo hi`"
               ^
[ -c flag ]:1: Invalid backtick: use $(cmd) or \` in YSH strings

===== CASE: -n -c setvar x = "\z" =====


  setvar x = "\z"
              ^
[ -c flag ]:1: Invalid char escape in double quoted string (OILS-ERR-12)
OK  test-ysh_dq_strings

test/ysh-parse-errors.sh: 58 tests passed.