ninja: no work to do.
*** 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) =====


(ExprCommand
  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) =====


(ExprCommand
  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) =====


(ExprCommand
  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(;) =====


(ExprCommand
  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;) =====


(ExprCommand
  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-assert-left-brackets

===== CASE: -c var x = [42]; assert [ [42] === x] =====


OK  test-assert-left-brackets
*** 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: Instead of $'', use J8 strings like b'' (no_parse_osh)
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 "}">
    )
    code_str:"                echo hi "
  )
  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 "'">
    )
  )
)
OK  test-bug_1825_backslashes
*** Running test-command-simple-more

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


(command.ShAssignment
  left:<Lit_VarLike "foo=">
  pairs:[
    (AssignPair
      left:...0x7f64f599fc20
      lhs:(sh_lhs.Name left:...0x7f64f599fc20 name:foo)
      op:assign_op.Equal
      rhs:(w <Lit_Number 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_Number 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.Simple
  blame_tok:<Lit_Chars cmd>
  more_env:[(EnvPair left:<Lit_VarLike "foo="> name:foo val:(w <Lit_Number 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}/ =====


(ExprCommand
  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']/ =====


(ExprCommand
  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+ / =====


(ExprCommand
  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 > / =====


(ExprCommand
  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 > / =====


(ExprCommand
  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 / =====


(ExprCommand
  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 / =====


(ExprCommand
  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 / =====


(ExprCommand
  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 / =====


(ExprCommand
  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 / =====


(ExprCommand
  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 / =====


(ExprCommand
  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+ ; / =====


(ExprCommand
  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 =====


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

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


(ExprCommand
  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() =====


(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 =====


(ExprCommand keyword:<Lit_Equals "="> e:(Const Expr_Float _))

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


(ExprCommand 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 (no_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:[
      (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:[
        (VarDecl
          lhs:[(NameType left:<Lit_Chars x> name:x)]
          rhs:(Const Expr_DecInt _)
        )
      ]
      right:<Lit_RBrace "}">
    )
    code_str:"      \n  x = 42\n"
  )
  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:[
        (VarDecl
          lhs:[(NameType left:<Lit_Chars x> name:x)]
          rhs:(Const Expr_DecInt _)
        )
      ]
      right:<Lit_RBrace "}">
    )
    code_str:"          \n  x = 42\n"
  )
  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:[
        (VarDecl
          lhs:[(NameType left:<Lit_Chars x> name:x)]
          rhs:(Const Expr_DecInt _)
        )
      ]
      right:<Lit_RBrace "}">
    )
    code_str:"         # inconsistent but OK\n  x = 42\n"
  )
  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:...0x7fb2246822f0
                          lhs:(sh_lhs.Name left:...0x7fb2246822f0 name:sudo)
                          op:assign_op.Equal
                          rhs:(w <Lit_Number 1>)
                        )
                      ]
                    )
                    (command.Simple
                      blame_tok:<Lit_Chars User>
                      more_env:[]
                      words:[(w <Lit_Chars User>)]
                      block:(LiteralBlock
                        brace_group:(BraceGroup
                          left:<Lit_LBrace "{">
                          children:[
                            (VarDecl
                              lhs:[(NameType left:<Lit_Chars name> name:name)]
                              rhs:(DQ <Lit_Chars z>)
                            )
                          ]
                          right:<Lit_RBrace "}">
                        )
                        code_str:"          \n      name = \"z\"\n    "
                      )
                      is_last_cmd:F
                    )
                  ]
                  right:<Lit_RBrace "}">
                )
                code_str:"             \n    sudo=1\n    User {\n      name = \"z\"\n    }\n  "
              )
              is_last_cmd:F
            )
          ]
          right:<Lit_RBrace "}">
        )
        code_str:"             \n  SHELL bob {\n    sudo=1\n    User {\n      name = \"z\"\n    }\n  }\n"
      )
      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 =====


(ExprCommand keyword:<Lit_Equals "="> e:(Const Expr_DecInt _))

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


(ExprCommand 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 =====


(ExprCommand 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
    (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)]
}
 =====


(ShFunction
  name_tok:<Lit_Chars f>
  name:f
  body:(BraceGroup
    left:<Lit_LBrace "{">
    children:[
      (C
        (w <Lit_Chars write>)
        (w <Lit_Chars -->)
        (w
          (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 "}">
  )
  code_str:"f() {\n  write -- @[sorted(x)]\n}"
)

===== 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 "}">
    )
    code_str:"                          echo hi "
  )
  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 "}">
    )
    code_str:"                         echo hi "
  )
  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_Number 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.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.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 =====


(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 =====


(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 =====


(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 =====


(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-backslashes

===== CASE: -n -c var x = ''' \n ''' =====


  var x = ''' \n '''
             ^~~~
[ -c flag ]:1: Ambiguous backslash: add explicit r'' or u'' prefix (OILS-ERR-20)

===== CASE: -n -c var x = r''' \n ''' =====


(VarDecl
  keyword:<KW_Var var>
  lhs:[(NameType left:<Expr_Name x> name:x)]
  rhs:(SingleQuoted
    left:<Left_RTSingleQuote "r'''">
    sval:" \\n "
    right:<Right_SingleQuote "'">
  )
)

===== CASE: -n -c var x = u''' \n ''' =====


(VarDecl
  keyword:<KW_Var var>
  lhs:[(NameType left:<Expr_Name x> name:x)]
  rhs:(SingleQuoted
    left:<Left_UTSingleQuote "u'''">
    sval:"\n"
    right:<Right_SingleQuote "'">
  )
)
OK  test-multiline-backslashes
*** 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 =====


(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-no-parse-dollar

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

===== 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 no_parse_dollar -n -c echo "$:" =====


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

===== 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 "${">
      name_tok:<VSub_Name x>
      var_name:x
      suffix_op:(suffix_op.Unary
        op:<VTest_ColonHyphen ":-">
        arg_word:(w <Lit_Dollar "$">)
      )
      right:<Right_DollarBrace "}">
    )
  )
)

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


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

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


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

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


(C
  (w <Lit_Chars echo>)
  (w
    (BracedVarSub
      left:<Left_DollarBrace "${">
      name_tok:<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 no_parse_dollar -n -c echo ${x:-$:} =====


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

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


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

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


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

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


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

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


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

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


(C
  (w <Lit_Chars echo>)
  (w
    (DQ
      (BracedVarSub
        left:<Left_DollarBrace "${">
        name_tok:<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 no_parse_dollar -n -c echo "${x:-$:}" =====


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

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


  echo "${x:-$:}"
             ^
[ -c flag ]:1: Literal $ should be quoted like \$ (no_parse_dollar)
OK  test-no-parse-dollar
*** Running test-no-parse-osh

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


  echo $'hi'
       ^~
[ -c flag ]:1: Instead of $'', use J8 strings like b'' (no_parse_osh)

===== CASE: -n -c var x = $'hi' =====


  var x = $'hi'
          ^~
[ -c flag ]:1: Instead of $'', use J8 strings like b'' (no_parse_osh)

===== CASE: -n -c sleep 2 & =====


  sleep 2 &
          ^
[ -c flag ]:1: Use the 'fork' builtin instead of &

===== CASE: -n -c sleep 2 & wait =====


  sleep 2 & wait
          ^
[ -c flag ]:1: Use the 'fork' builtin instead of &

===== CASE: -n -c { sleep 2 & } =====


  { sleep 2 & }
            ^
[ -c flag ]:1: Use the 'fork' builtin instead of &

===== CASE: -n -c ( cd /tmp && ls ) =====


  ( cd /tmp && ls )
  ^
[ -c flag ]:1: Subshell syntax ( ) isn't allowed in YSH (OILS-ERR-19)

===== CASE: -n -c { ( cd /tmp && ls ) } =====


  { ( cd /tmp && ls ) }
    ^
[ -c flag ]:1: Subshell syntax ( ) isn't allowed in YSH (OILS-ERR-19)
OK  test-no-parse-osh
*** 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 (no_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:...0x1246
      cond:[
        (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:...0x11be
    )
  ]
  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 (no_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 (no_parse_dparen)

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


(command.If
  if_kw:<KW_If if>
  arms:[
    (IfArm
      keyword:...0x7f001b188c20
      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:...0x7fe394968c20
      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-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)) =====


  echo $(json write (x))
                       ^
[ -c flag ]:1: Invalid word while parsing command list

test/ysh-parse-errors.sh: fatal: Should parse with _bin/cxx-asan/osh: expected status 0, got 2
FAIL  test-proc-args