*** Running test-parse-osh
---
(command.CommandList
  children: [
    (command.Simple
      words: [{<shopt>} {<-s>} {<oil-parse-at>} {<static-word-eval>}]
      redirects: []
      more_env: []
      do_fork: T
    )
    (command.ShAssignment
      pairs: [
        (AssignPair
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'myglobal='> name:myglobal)
          op: assign_op.Equal
          rhs: {<global>}
          spids: [10]
        )
      ]
      redirects: []
    )
    (command.VarDecl
      keyword: <Id.KW_Var var>
      lhs: [(NameType name:<Id.Expr_Name myarray>)]
      rhs: 
        (ShArrayLiteral
          left: <Id.Left_PercentParen '%('>
          words: [
            {($ Id.VSub_DollarName myglobal)}
            {
              (SingleQuoted
                left: <Id.Left_DollarSingleQuote '$\''>
                tokens: [<Id.Char_Literals line> <Id.Char_OneChar '\\n'>]
                right: <Id.Right_SingleQuote '\''>
              )
            }
            {
              (BracedVarSub
                left: <Id.Left_DollarBrace '${'>
                token: <Id.VSub_Name z>
                var_name: z
                suffix_op: (suffix_op.Unary op:<Id.VTest_ColonHyphen _> arg_word:{<default>})
                right: <Id.Right_DollarBrace '}'>
              )
            }
          ]
        )
    )
    (command.Simple
      words: [{<'spec/bin/argv.py'>} {<Id.Lit_Splice '@myarray'>}]
      redirects: []
      more_env: []
      do_fork: T
    )
    (command.Simple
      words: [
        {<echo>}
        {<Id.Lit_VarLike 'len='> 
          (BracedVarSub
            left: <Id.Left_DollarBrace '${'>
            token: <Id.VSub_Name myarray>
            var_name: myarray
            prefix_op: <Id.VSub_Pound '#'>
            bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
            right: <Id.Right_DollarBrace '}'>
          )
        }
      ]
      redirects: []
      more_env: []
      do_fork: T
    )
    (command.Simple words:[{<echo>}] redirects:[] more_env:[] do_fork:T)
    (command.Simple
      words: [
        {<append>}
        {<myarray>}
        {<Id.Lit_Underscore _>}
        {(SQ <'1 2'>)}
        {
          (BracedVarSub
            left: <Id.Left_DollarBrace '${'>
            token: <Id.VSub_Name myglobal>
            var_name: myglobal
            suffix_op: (suffix_op.Unary op:<Id.VTest_ColonHyphen _> arg_word:{<default>})
            right: <Id.Right_DollarBrace '}'>
          )
        }
      ]
      redirects: []
      more_env: []
      do_fork: T
    )
    (command.Simple
      words: [{<'spec/bin/argv.py'>} {<Id.Lit_Splice '@myarray'>}]
      redirects: []
      more_env: []
      do_fork: T
    )
    (command.Simple
      words: [
        {<echo>}
        {<Id.Lit_VarLike 'len='> 
          (BracedVarSub
            left: <Id.Left_DollarBrace '${'>
            token: <Id.VSub_Name myarray>
            var_name: myarray
            prefix_op: <Id.VSub_Pound '#'>
            bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
            right: <Id.Right_DollarBrace '}'>
          )
        }
      ]
      redirects: []
      more_env: []
      do_fork: T
    )
    (command.Simple words:[{<echo>}] redirects:[] more_env:[] do_fork:T)
    (command.ForEach
      keyword: <Id.KW_For for>
      iter_names: [item]
      iterable: 
        (for_iter.Words
          words: [
            {
              (DQ 
                (BracedVarSub
                  left: <Id.Left_DollarBrace '${'>
                  token: <Id.VSub_Name myarray>
                  var_name: myarray
                  bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                  right: <Id.Right_DollarBrace '}'>
                )
              )
            }
          ]
        )
      body: 
        (command.DoGroup
          left: <Id.KW_Do do>
          children: [
            (command.Simple
              words: [{<echo>} {(DQ <'  '> ($ Id.VSub_DollarName item))}]
              redirects: []
              more_env: []
              do_fork: T
            )
          ]
          right: <Id.KW_Done done>
        )
      redirects: []
    )
  ]
)
---
(command.CommandList
  children: [
    (command.ShFunction
      name: argv
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.Sentence
              child: 
                (command.Simple
                  words: [{<'spec/bin/argv.py'>} {(DQ ($ Id.VSub_At '@'))}]
                  redirects: []
                  more_env: []
                  do_fork: T
                )
              terminator: <Id.Op_Semi _>
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShAssignment
      pairs: [
        (AssignPair
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'regex='> name:regex)
          op: assign_op.Equal
          rhs: {(ShArrayLiteral left:<Id.Op_LParen _> words:[{<old1>} {<old2>}])}
          spids: [45]
        )
      ]
      redirects: []
    )
    (command.ShAssignment
      pairs: [
        (AssignPair
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'flags='> name:flags)
          op: assign_op.Equal
          rhs: {(ShArrayLiteral left:<Id.Op_LParen _> words:[])}
          spids: [52]
        )
      ]
      redirects: []
    )
    (command.ForEach
      keyword: <Id.KW_For for>
      iter_names: [r]
      iterable: 
        (for_iter.Words
          words: [
            {
              (DQ 
                (BracedVarSub
                  left: <Id.Left_DollarBrace '${'>
                  token: <Id.VSub_Name regex>
                  var_name: regex
                  bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                  right: <Id.Right_DollarBrace '}'>
                )
              )
            }
          ]
        )
      body: 
        (command.DoGroup
          left: <Id.KW_Do do>
          children: [
            (command.ShAssignment
              pairs: [
                (AssignPair
                  lhs: 
                    (sh_lhs_expr.IndexedName
                      left: <Id.Lit_ArrayLhsOpen 'flags['>
                      name: flags
                      index: 
                        {
                          (BracedVarSub
                            left: <Id.Left_DollarBrace '${'>
                            token: <Id.VSub_Name flags>
                            var_name: flags
                            prefix_op: <Id.VSub_Pound '#'>
                            bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                            right: <Id.Right_DollarBrace '}'>
                          )
                        }
                    )
                  op: assign_op.Equal
                  rhs: {(DQ <'--regex='> ($ Id.VSub_DollarName r))}
                  spids: [76]
                )
              ]
              redirects: []
            )
          ]
          right: <Id.KW_Done done>
        )
      redirects: []
    )
    (command.Simple
      words: [
        {<argv>}
        {
          (DQ 
            (BracedVarSub
              left: <Id.Left_DollarBrace '${'>
              token: <Id.VSub_Name flags>
              var_name: flags
              bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
              right: <Id.Right_DollarBrace '}'>
            )
          )
        }
      ]
      redirects: []
      more_env: []
      do_fork: T
    )
    (command.Simple
      words: [{<shopt>} {<-s>} {<simple_word_eval>} {<parse_at>}]
      redirects: []
      more_env: []
      do_fork: T
    )
    (command.VarDecl
      keyword: <Id.KW_Var var>
      lhs: [(NameType name:<Id.Expr_Name regex2>)]
      rhs: (ShArrayLiteral left:<Id.Left_PercentParen '%('> words:[{<new1>} {<new2>}])
    )
    (command.VarDecl
      keyword: <Id.KW_Var var>
      lhs: [(NameType name:<Id.Expr_Name flags2>)]
      rhs: (ShArrayLiteral left:<Id.Left_PercentParen '%('> words:[])
    )
    (command.ForEach
      keyword: <Id.KW_For for>
      iter_names: [r]
      iterable: (for_iter.Words words:[{<Id.Lit_Splice '@regex2'>}])
      body: 
        (command.DoGroup
          left: <Id.KW_Do do>
          children: [
            (command.Simple
              words: [
                {<append>}
                {<Id.Lit_Colon ':'> <flags2>}
                {(DQ <'--regex='> ($ Id.VSub_DollarName r))}
              ]
              redirects: []
              more_env: []
              do_fork: T
            )
          ]
          right: <Id.KW_Done done>
        )
      redirects: []
    )
    (command.Simple
      words: [{<argv>} {<Id.Lit_Splice '@flags2'>}]
      redirects: []
      more_env: []
      do_fork: T
    )
  ]
)
---
(command.CommandList
  children: [
    (command.Simple
      words: [{<echo>} {(SQ <'This is a shell script with OSH extensions!'>)}]
      redirects: []
      more_env: []
      do_fork: T
    )
    (command.Simple words:[{<echo>}] redirects:[] more_env:[] do_fork:T)
    (command.VarDecl
      keyword: <Id.KW_Var var>
      lhs: [(NameType name:<Id.Expr_Name x>)]
      rhs: 
        (expr.Binary
          op: <Id.Arith_Plus _>
          left: (expr.Const c:<Id.Expr_DecInt 1>)
          right: 
            (expr.Binary
              op: <Id.Arith_Star _>
              left: (expr.Const c:<Id.Expr_DecInt 2>)
              right: (expr.Const c:<Id.Expr_DecInt 3>)
            )
        )
    )
    (command.Simple
      words: [{<echo>} {(DQ <'x: '> ($ Id.VSub_DollarName x))}]
      redirects: []
      more_env: []
      do_fork: T
    )
    (command.PlaceMutation
      keyword: <Id.KW_SetVar setvar>
      lhs: [(place_expr.Var name:<Id.Expr_Name x>)]
      op: <Id.Arith_PlusEqual _>
      rhs: (expr.Const c:<Id.Expr_DecInt 1>)
    )
    (command.Simple
      words: [{<echo>} {(DQ <'x: '> ($ Id.VSub_DollarName x))}]
      redirects: []
      more_env: []
      do_fork: T
    )
    (command.VarDecl
      keyword: <Id.KW_Var var>
      lhs: [(NameType name:<Id.Expr_Name mylist>)]
      rhs: 
        (expr.List
          elts: [
            (expr.Const c:<Id.Expr_DecInt 1>)
            (expr.Const c:<Id.Expr_DecInt 2>)
            (expr.Const c:<Id.Expr_DecInt 3>)
          ]
          ctx: expr_context.Store
        )
    )
    (command.VarDecl
      keyword: <Id.KW_Var var>
      lhs: [(NameType name:<Id.Expr_Name y>)]
      rhs: 
        (expr.Binary
          op: <Id.Arith_Star _>
          left: 
            (Subscript
              obj: (expr.Var name:<Id.Expr_Name mylist>)
              indices: [(expr.Const c:<Id.Expr_DecInt 1>)]
            )
          right: (expr.Const c:<Id.Expr_DecInt 10>)
        )
    )
    (command.Simple
      words: [{<echo>} {(DQ <'y: '> ($ Id.VSub_DollarName y))}]
      redirects: []
      more_env: []
      do_fork: T
    )
    (command.VarDecl
      keyword: <Id.KW_Var var>
      lhs: [(NameType name:<Id.Expr_Name list2>)]
      rhs: 
        (expr.Binary
          op: <Id.Arith_DPlus _>
          left: (expr.Var name:<Id.Expr_Name mylist>)
          right: 
            (expr.List
              elts: [(expr.Const c:<Id.Expr_DecInt 4>) (expr.Const c:<Id.Expr_DecInt 5>)]
              ctx: expr_context.Store
            )
        )
    )
    (command.Simple words:[{<pp>} {<cell>} {<list2>}] redirects:[] more_env:[] do_fork:T)
    (command.ShAssignment
      pairs: [
        (AssignPair
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'str1='> name:str1)
          op: assign_op.Equal
          rhs: {(SQ <'shell string'>)}
          spids: [130]
        )
      ]
      redirects: []
    )
    (command.VarDecl
      keyword: <Id.KW_Var var>
      lhs: [(NameType name:<Id.Expr_Name str2>)]
      rhs: (DQ <'Oil string'>)
    )
    (command.VarDecl
      keyword: <Id.KW_Var var>
      lhs: [(NameType name:<Id.Expr_Name str3>)]
      rhs: 
        (expr.Binary
          op: <Id.Arith_DPlus _>
          left: (expr.Var name:<Id.Expr_Name str1>)
          right: (expr.Var name:<Id.Expr_Name str2>)
        )
    )
    (command.Simple
      words: [{<echo>} {(DQ <'str3 = '> ($ Id.VSub_DollarName str3))}]
      redirects: []
      more_env: []
      do_fork: T
    )
  ]
)
---
(command.CommandList
  children: [
    (command.ShFunction
      name: argv
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.Simple
              words: [
                {<python>}
                {<-c>}
                {(SQ <'import sys;print(sys.argv[1:])'>)}
                {<Id.Lit_Splice '@ARGV'>}
              ]
              redirects: []
              more_env: []
              do_fork: T
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name: show
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.Simple
              words: [{<echo>} {(SQ <'====='>)}]
              redirects: []
              more_env: []
              do_fork: T
            )
            (command.Simple
              words: [{<argv>} {<Id.Lit_Splice '@ARGV'>}]
              redirects: []
              more_env: []
              do_fork: T
            )
            (command.Simple words:[{<echo>}] redirects:[] more_env:[] do_fork:T)
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.VarDecl
      keyword: <Id.KW_Var var>
      lhs: [(NameType name:<Id.Expr_Name strarray>)]
      rhs: 
        (ShArrayLiteral
          left: <Id.Left_PercentParen '%('>
          words: [
            {<bare>}
            {<words>}
            {<Id.Lit_Star '*'> <.sh>}
            (word.BracedTree
              parts: [(word_part.BracedTuple words:[{<a>} {<b>}]) <Id.Lit_Splice '@example'> <.com>]
            )
            {(SQ <sq>)}
            {
              (DQ <'dq '> 
                (BracedVarSub
                  left: <Id.Left_DollarBrace '${'>
                  token: <Id.VSub_Name x>
                  var_name: x
                  suffix_op: (suffix_op.Unary op:<Id.VTest_ColonHyphen _> arg_word:{<default>})
                  right: <Id.Right_DollarBrace '}'>
                )
              )
            }
          ]
        )
    )
    (command.Simple
      words: [{<show>} {<Id.Lit_Splice '@strarray'>}]
      redirects: []
      more_env: []
      do_fork: T
    )
    (command.VarDecl
      keyword: <Id.KW_Var var>
      lhs: [(NameType name:<Id.Expr_Name cmd_sub>)]
      rhs: 
        (CommandSub
          left_token: <Id.Left_DollarParen '$('>
          child: 
            (command.Simple
              words: [
                {<echo>}
                {<bare>}
                {<words>}
                {<Id.Lit_Star '*'> <.sh>}
                (word.BracedTree
                  parts: [(word_part.BracedTuple words:[{<a>} {<b>}]) <Id.Lit_Splice '@example'> <.com>]
                )
                {(SQ <sq>)}
                {
                  (DQ <'dq '> 
                    (BracedVarSub
                      left: <Id.Left_DollarBrace '${'>
                      token: <Id.VSub_Name x>
                      var_name: x
                      suffix_op: (suffix_op.Unary op:<Id.VTest_ColonHyphen _> arg_word:{<default>})
                      right: <Id.Right_DollarBrace '}'>
                    )
                  )
                }
              ]
              redirects: []
              more_env: []
              do_fork: T
            )
          right: <Id.Eof_RParen _>
        )
    )
    (command.Simple
      words: [{<show>} {($ Id.VSub_DollarName cmd_sub)}]
      redirects: []
      more_env: []
      do_fork: T
    )
    (command.Simple
      words: [
        {<show>}
        {
          (word_part.ExprSub
            left: <Id.Left_DollarBracket '$['>
            child: 
              (expr.Binary
                op: <Id.Arith_DPlus _>
                left: (SQ <'quoted '>)
                right: 
                  (expr.Binary
                    op: <Id.Arith_DPlus _>
                    left: (SQ <'words '>)
                    right: 
                      (DQ <'dq '> 
                        (BracedVarSub
                          left: <Id.Left_DollarBrace '${'>
                          token: <Id.VSub_Name x>
                          var_name: x
                          suffix_op: (suffix_op.Unary op:<Id.VTest_ColonHyphen _> arg_word:{<default>})
                          right: <Id.Right_DollarBrace '}'>
                        )
                      )
                  )
              )
          )
        }
      ]
      redirects: []
      more_env: []
      do_fork: T
    )
  ]
)
---
(command.CommandList
  children: [
    (command.Simple
      words: [
        {<echo>}
        {
          (SingleQuoted
            left: <Id.Left_DollarSingleQuote '$\''>
            tokens: [<Id.Char_Literals one> <Id.Char_OneChar '\\n'> <Id.Char_Literals two>]
            right: <Id.Right_SingleQuote '\''>
          )
        }
      ]
      redirects: []
      more_env: []
      do_fork: T
    )
    (command.VarDecl
      keyword: <Id.KW_Var var>
      lhs: [(NameType name:<Id.Expr_Name a>)]
      rhs: 
        (expr.Binary
          op: <Id.Arith_Plus _>
          left: (expr.Const c:<Id.Expr_DecInt 1>)
          right: 
            (expr.Binary
              op: <Id.Arith_Star _>
              left: (expr.Const c:<Id.Expr_DecInt 2>)
              right: (expr.Const c:<Id.Expr_DecInt 3>)
            )
        )
    )
    (command.Simple
      words: [{<echo>} {<Id.Lit_VarLike 'a='> ($ Id.VSub_DollarName a)}]
      redirects: []
      more_env: []
      do_fork: T
    )
    (command.VarDecl
      keyword: <Id.KW_Var var>
      lhs: [(NameType name:<Id.Expr_Name b>)]
      rhs: 
        (expr.Binary
          op: <Id.Arith_Slash _>
          left: (expr.Const c:<Id.Expr_DecInt 5>)
          right: (expr.Const c:<Id.Expr_DecInt 6>)
        )
    )
    (command.Simple
      words: [{<echo>} {<Id.Lit_VarLike 'b='> ($ Id.VSub_DollarName b)}]
      redirects: []
      more_env: []
      do_fork: T
    )
    (command.Simple words:[{<echo>} {<hi>}] redirects:[] more_env:[] do_fork:T)
    (command.CommandList
      children: [
        (command.Sentence
          child: 
            (command.PlaceMutation
              keyword: <Id.KW_SetVar setvar>
              lhs: [(place_expr.Var name:<Id.Expr_Name a>)]
              op: <Id.Arith_Equal _>
              rhs: (expr.Var name:<Id.Expr_Name b>)
            )
          terminator: <Id.Op_Semi _>
        )
        (command.Simple words:[{<echo>} {<hi>}] redirects:[] more_env:[] do_fork:T)
      ]
    )
    (command.PlaceMutation
      keyword: <Id.KW_SetVar setvar>
      lhs: [(place_expr.Var name:<Id.Expr_Name x>)]
      op: <Id.Arith_Equal _>
      rhs: (expr.Const c:<Id.Expr_DecInt 4>)
    )
    (command.PlaceMutation
      keyword: <Id.KW_SetVar setvar>
      lhs: [(place_expr.Var name:<Id.Expr_Name d>)]
      op: <Id.Arith_Equal _>
      rhs: (expr.Const c:<Id.Expr_DecInt 1>)
    )
    (command.VarDecl
      keyword: <Id.KW_Var var>
      lhs: [(NameType name:<Id.Expr_Name y>) (NameType name:<Id.Expr_Name z>)]
      rhs: 
        (expr.Tuple
          elts: [(expr.Var name:<Id.Expr_Name a>) (expr.Var name:<Id.Expr_Name b>)]
          ctx: expr_context.Store
        )
    )
    (command.Simple words:[{<echo>} {<hi>}] redirects:[] more_env:[] do_fork:T)
    (command.VarDecl
      keyword: <Id.KW_Var var>
      lhs: [(NameType name:<Id.Expr_Name mycmd>)]
      rhs: 
        (expr.Binary
          op: <Id.Arith_Plus _>
          left: 
            (CommandSub
              left_token: <Id.Left_DollarParen '$('>
              child: (command.Simple words:[{<echo>} {<cmd>}] redirects:[] more_env:[] do_fork:T)
              right: <Id.Eof_RParen _>
            )
          right: 
            (DQ 
              (CommandSub
                left_token: <Id.Left_DollarParen '$('>
                child: (command.Simple words:[{<echo>} {<cmd>}] redirects:[] more_env:[] do_fork:T)
                right: <Id.Eof_RParen _>
              )
            )
        )
    )
    (command.Simple
      words: [{<echo>} {<Id.Lit_VarLike 'mycmd='> ($ Id.VSub_DollarName mycmd)}]
      redirects: []
      more_env: []
      do_fork: T
    )
    (command.VarDecl
      keyword: <Id.KW_Var var>
      lhs: [(NameType name:<Id.Expr_Name mybrace>)]
      rhs: (expr.Binary op:<Id.Arith_Plus _> left:(${ Id.VSub_Name b) right:(DQ (${ Id.VSub_Name b)))
    )
    (command.Simple
      words: [{<echo>} {<Id.Lit_VarLike 'mybrace='> ($ Id.VSub_DollarName mybrace)}]
      redirects: []
      more_env: []
      do_fork: T
    )
    (command.VarDecl
      keyword: <Id.KW_Var var>
      lhs: [(NameType name:<Id.Expr_Name paren>)]
      rhs: 
        (expr.Binary
          op: <Id.Arith_Star _>
          left: 
            (expr.Binary
              op: <Id.Arith_Plus _>
              left: (expr.Const c:<Id.Expr_DecInt 1>)
              right: (expr.Const c:<Id.Expr_DecInt 2>)
            )
          right: (expr.Const c:<Id.Expr_DecInt 3>)
        )
    )
    (command.Simple
      words: [{<echo>} {<Id.Lit_VarLike 'paren='> ($ Id.VSub_DollarName paren)}]
      redirects: []
      more_env: []
      do_fork: T
    )
    (command.VarDecl
      keyword: <Id.KW_Var var>
      lhs: [(NameType name:<Id.Expr_Name line_cont>)]
      rhs: 
        (expr.Binary
          op: <Id.Arith_Plus _>
          left: (expr.Const c:<Id.Expr_DecInt 4>)
          right: (expr.Const c:<Id.Expr_DecInt 5>)
        )
    )
    (command.Simple
      words: [{<echo>} {<Id.Lit_VarLike 'line_cont='> ($ Id.VSub_DollarName line_cont)}]
      redirects: []
      more_env: []
      do_fork: T
    )
    (command.VarDecl
      keyword: <Id.KW_Var var>
      lhs: [(NameType name:<Id.Expr_Name multiline>)]
      rhs: 
        (expr.Binary
          op: <Id.Arith_Plus _>
          left: (expr.Const c:<Id.Expr_DecInt 6>)
          right: (expr.Const c:<Id.Expr_DecInt 7>)
        )
    )
    (command.Simple
      words: [{<echo>} {<Id.Lit_VarLike 'multiline='> ($ Id.VSub_DollarName multiline)}]
      redirects: []
      more_env: []
      do_fork: T
    )
    (command.VarDecl
      keyword: <Id.KW_Var var>
      lhs: [(NameType name:<Id.Expr_Name aug>)]
      rhs: (expr.Const c:<Id.Expr_DecInt 8>)
    )
    (command.PlaceMutation
      keyword: <Id.KW_SetVar setvar>
      lhs: [(place_expr.Var name:<Id.Expr_Name aug>)]
      op: <Id.Arith_PlusEqual _>
      rhs: (expr.Const c:<Id.Expr_DecInt 9>)
    )
    (command.Simple
      words: [{<echo>} {<Id.Lit_VarLike 'aug='> ($ Id.VSub_DollarName aug)}]
      redirects: []
      more_env: []
      do_fork: T
    )
  ]
)
---
(command.CommandList
  children: [
    (command.ShFunction
      name: argv
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.Sentence
              child: 
                (command.Simple
                  words: [{<'spec/bin/argv.py'>} {(DQ ($ Id.VSub_At '@'))}]
                  redirects: []
                  more_env: []
                  do_fork: T
                )
              terminator: <Id.Op_Semi _>
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShAssignment
      pairs: [
        (AssignPair
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'CONFIG_HAVE_FOO='> name:CONFIG_HAVE_FOO)
          op: assign_op.Equal
          rhs: {<yes>}
          spids: [48]
        )
      ]
      redirects: []
    )
    (command.ShAssignment
      pairs: [
        (AssignPair
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'path='> name:path)
          op: assign_op.Equal
          rhs: {(SQ <'/etc/path with spaces'>)}
          spids: [51]
        )
      ]
      redirects: []
    )
    (command.ShAssignment
      pairs: [
        (AssignPair
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'flags='> name:flags)
          op: assign_op.Equal
          rhs: {(SQ )}
          spids: [56]
        )
      ]
      redirects: []
    )
    (command.If
      if_kw: <Id.KW_If if>
      arms: [
        (IfArm
          keyword: <Id.KW_If if>
          cond: 
            (condition.Shell
              commands: [
                (command.Sentence
                  child: 
                    (command.Simple
                      words: [
                        {<Id.Lit_LBracket '['>}
                        {<-n>}
                        {(DQ (${ Id.VSub_Name CONFIG_HAVE_FOO))}
                        {<Id.Lit_RBracket ']'>}
                      ]
                      redirects: []
                      more_env: []
                      do_fork: T
                    )
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          then_kw: <Id.KW_Then then>
          action: [
            (command.ShAssignment
              pairs: [
                (AssignPair
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'flags='> name:flags)
                  op: assign_op.Equal
                  rhs: {(DQ (${ Id.VSub_Name flags) <' --foo='> ($ Id.VSub_DollarName path))}
                  spids: [80]
                )
              ]
              redirects: []
            )
          ]
          spids: [62 77]
        )
      ]
      else_action: []
      fi_kw: <Id.KW_Fi fi>
      redirects: []
    )
    (command.If
      if_kw: <Id.KW_If if>
      arms: [
        (IfArm
          keyword: <Id.KW_If if>
          cond: 
            (condition.Shell
              commands: [
                (command.Sentence
                  child: 
                    (command.Simple
                      words: [
                        {<Id.Lit_LBracket '['>}
                        {<-n>}
                        {(DQ (${ Id.VSub_Name CONFIG_HAVE_BAR))}
                        {<Id.Lit_RBracket ']'>}
                      ]
                      redirects: []
                      more_env: []
                      do_fork: T
                    )
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          then_kw: <Id.KW_Then then>
          action: [
            (command.ShAssignment
              pairs: [
                (AssignPair
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'flags='> name:flags)
                  op: assign_op.Equal
                  rhs: {(DQ (${ Id.VSub_Name flags) <' --bar'>)}
                  spids: [110]
                )
              ]
              redirects: []
            )
          ]
          spids: [92 107]
        )
      ]
      else_action: []
      fi_kw: <Id.KW_Fi fi>
      redirects: []
    )
    (command.Simple
      words: [{<argv>} {(${ Id.VSub_Name flags)}]
      redirects: []
      more_env: []
      do_fork: T
    )
    (command.Simple words:[{<set>} {<-o>} {<errexit>}] redirects:[] more_env:[] do_fork:T)
    (command.Simple
      words: [{<shopt>} {<-s>} {<parse_at>} {<simple_word_eval>}]
      redirects: []
      more_env: []
      do_fork: T
    )
    (command.PlaceMutation
      keyword: <Id.KW_SetVar setvar>
      lhs: [(place_expr.Var name:<Id.Expr_Name CONFIG_HAVE_FOO>)]
      op: <Id.Arith_Equal _>
      rhs: (DQ <yes>)
    )
    (command.PlaceMutation
      keyword: <Id.KW_SetVar setvar>
      lhs: [(place_expr.Var name:<Id.Expr_Name path>)]
      op: <Id.Arith_Equal _>
      rhs: (DQ <'/etc/path with spaces'>)
    )
    (command.PlaceMutation
      keyword: <Id.KW_SetVar setvar>
      lhs: [(place_expr.Var name:<Id.Expr_Name flags>)]
      op: <Id.Arith_Equal _>
      rhs: (ShArrayLiteral left:<Id.Left_PercentParen '%('> words:[])
    )
    (command.If
      if_kw: <Id.KW_If if>
      arms: [
        (IfArm
          keyword: <Id.KW_If if>
          cond: 
            (condition.Shell
              commands: [
                (command.Sentence
                  child: 
                    (command.Simple
                      words: [{<test>} {<-n>} {($ Id.VSub_DollarName CONFIG_HAVE_FOO)}]
                      redirects: []
                      more_env: []
                      do_fork: T
                    )
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          then_kw: <Id.KW_Then then>
          action: [
            (command.Simple
              words: [
                {<append>}
                {<Id.Lit_Colon ':'> <flags>}
                {<--foo> <Id.Lit_Equals '='> ($ Id.VSub_DollarName path)}
              ]
              redirects: []
              more_env: []
              do_fork: T
            )
          ]
          spids: [204 213]
        )
      ]
      else_action: []
      fi_kw: <Id.KW_Fi fi>
      redirects: []
    )
    (command.If
      if_kw: <Id.KW_If if>
      arms: [
        (IfArm
          keyword: <Id.KW_If if>
          cond: 
            (condition.Shell
              commands: [
                (command.Sentence
                  child: 
                    (command.Simple
                      words: [{<test>} {<-n>} {($ Id.VSub_DollarName CONFIG_HAVE_BAR)}]
                      redirects: []
                      more_env: []
                      do_fork: T
                    )
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          then_kw: <Id.KW_Then then>
          action: [
            (command.Simple
              words: [{<append>} {<Id.Lit_Colon ':'> <flags>} {<--bar>}]
              redirects: []
              more_env: []
              do_fork: T
            )
          ]
          spids: [228 237]
        )
      ]
      else_action: []
      fi_kw: <Id.KW_Fi fi>
      redirects: []
    )
    (command.Simple
      words: [{<argv>} {<Id.Lit_Splice '@flags'>}]
      redirects: []
      more_env: []
      do_fork: T
    )
  ]
)
---
(command.CommandList
  children: [
    (command.ShAssignment
      pairs: [
        (AssignPair
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'global_var='> name:global_var)
          op: assign_op.Equal
          rhs: {<global>}
          spids: [0]
        )
      ]
      redirects: []
    )
    (command.ShFunction
      name: g
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.Simple
              words: [{<local>} {<Id.Lit_VarLike 'g_var='> <f>}]
              redirects: []
              more_env: []
              do_fork: T
            )
            (command.Simple
              words: [{<echo>} {($ Id.VSub_DollarName g_var)}]
              redirects: []
              more_env: []
              do_fork: T
            )
            (command.Simple
              words: [{<echo>} {($ Id.VSub_DollarName f_var)}]
              redirects: []
              more_env: []
              do_fork: T
            )
            (command.VarDecl
              keyword: <Id.KW_Var var>
              lhs: [(NameType name:<Id.Expr_Name oil_var>)]
              rhs: (expr.Var name:<Id.Expr_Name global_var>)
            )
            (command.Simple
              words: [{<echo>} {($ Id.VSub_DollarName oil_var)}]
              redirects: []
              more_env: []
              do_fork: T
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name: f
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.Simple
              words: [{<local>} {<Id.Lit_VarLike 'f_var='> <f>}]
              redirects: []
              more_env: []
              do_fork: T
            )
            (command.Simple
              words: [{<echo>} {($ Id.VSub_DollarName f_var)}]
              redirects: []
              more_env: []
              do_fork: T
            )
            (command.Simple words:[{<g>}] redirects:[] more_env:[] do_fork:T)
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.Simple words:[{<f>}] redirects:[] more_env:[] do_fork:T)
  ]
)
OK  test-parse-osh
*** Running test-run-oil
---
hello 42
---
+ Call in expression context:
3

+ Inline call that coerces to string:
3
3


+ Inline calls can be part of a word:
--length=3
33

+ Caveat: can't double quote.  It would break programs.
  Should we add an option 'shopt -s parse_dparen'?

--length=3

+ Just as you can splice @myarray
spam
eggs
ham

+ You can also splice the result of a function returning a sequence:
  Notes:
  - the sorted() function is from Python.
  - sorting utf-8 encoded strings as bytes is well-defined

eggs
ham
spam

Parts:
aaa
BB
c

join(parts):
aaaBBc

+ Another way of doing it, without creating another variable:
aaaBBc

j => aaa:BB:c
When IFS is the default, split(j) => 
aaa:BB:c

When IFS is :, split(j) => 
aaa
BB
c

+ Since there is no word splitting of unquoted $(ls), here is an idiom:
bin/
lib/
---
Hello world!
first line
second line
Some string
Some string
$myvar
Some string
Some st
Some s
11
DefaultValueIfFooIsMissingOrEmpty
---
perhaps it's already here
42
I am just a normal string
I am just a normal string and I am just a normal string
I am just a normal string_
I am some string
\n


mu = μ
Hello world!
I'm just a string
it's true I really do 

it's true I really do 
Not a file
I'm an abstraction
I'm passed
hi
OK
2023
Here I am!
date: unrecognized option '--wrong-flag'
Try 'date --help' for more information.
will never be executed
number
2023-05-03
2023
OK  test-run-oil
*** Running test-run-osh
oil_lang/testdata/array-rewrite-1.sh
---
['--regex=old1', '--regex=old2']
['--regex=new1', '--regex=new2']
oil_lang/testdata/array-rewrite-2.sh
---
['--foo=/etc/path', 'with', 'spaces']
['--foo=/etc/path with spaces']
oil_lang/testdata/sigil-pairs.sh
---
=====
['@ARGV']

=====
['@ARGV']

=====
['@ARGV']

oil_lang/testdata/array-splice-demo.osh
---
  shopt -s oil-parse-at static-word-eval
  ^~~~~
'oil_lang/testdata/array-splice-demo.osh':2: 'shopt' got invalid option 'oil-parse-at'
['@myarray']
len=3

['@myarray']
len=6

  global
  line

  default
  _
  1 2
  global
oil_lang/testdata/assign.osh
skipping oil_lang/testdata/assign.osh
oil_lang/testdata/hello.osh
---
This is a shell script with OSH extensions!

x: 7
x: 8
y: 20
list2 = (Cell exported:F readonly:F nameref:F val:(value.Obj obj:[1, 2, 3, 4, 5]))
str3 = shell stringOil string
oil_lang/testdata/no-dynamic-scope.osh
skipping oil_lang/testdata/no-dynamic-scope.osh
OK  test-run-osh

oil_lang/run.sh: 3 tests passed.