*** Running test-parse-osh
(command.CommandList
  children: [
    (C {<shopt>} {<-s>} {<oil-parse-at>} {<static-word-eval>})
    (command.ShAssignment
      pairs: [
        (assign_pair
          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: [(name_type name:<Id.Expr_Name myarray>)]
      rhs: 
        (sh_array_literal
          left: <Id.Left_PercentParen '%('>
          words: [
            {($ Id.VSub_DollarName myglobal)}
            {
              (single_quoted
                left: <Id.Left_DollarSingleQuote '$\''>
                tokens: [<Id.Char_Literals line> <Id.Char_OneChar '\\n'>]
                right: <Id.Right_SingleQuote '\''>
              )
            }
            {
              (braced_var_sub
                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 '}'>
              )
            }
          ]
        )
    )
    (C {<'spec/bin/argv.py'>} {<Id.Lit_Splice '@myarray'>})
    (C {<echo>} 
      {<Id.Lit_VarLike 'len='> 
        (braced_var_sub
          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 '}'>
        )
      }
    )
    (C {<echo>})
    (C {<append>} {<myarray>} {<Id.Lit_Underscore _>} {(SQ <'1 2'>)} 
      {
        (braced_var_sub
          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 '}'>
        )
      }
    )
    (C {<'spec/bin/argv.py'>} {<Id.Lit_Splice '@myarray'>})
    (C {<echo>} 
      {<Id.Lit_VarLike 'len='> 
        (braced_var_sub
          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 '}'>
        )
      }
    )
    (C {<echo>})
    (command.ForEach
      iter_names: [item]
      iterable: 
        (for_iter.Words
          words: [
            {
              (DQ 
                (braced_var_sub
                  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 children:[(C {<echo>} {(DQ <'  '> ($ Id.VSub_DollarName item))})])
      redirects: []
    )
  ]
)
(command.CommandList
  children: [
    (command.ShFunction
      name: argv
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.Sentence
              child: (C {<'spec/bin/argv.py'>} {(DQ ($ Id.VSub_At '@'))})
              terminator: <Id.Op_Semi _>
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'regex='> name:regex)
          op: assign_op.Equal
          rhs: {(sh_array_literal left:<Id.Op_LParen _> words:[{<old1>} {<old2>}])}
          spids: [45]
        )
      ]
      redirects: []
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'flags='> name:flags)
          op: assign_op.Equal
          rhs: {(sh_array_literal left:<Id.Op_LParen _> words:[])}
          spids: [52]
        )
      ]
      redirects: []
    )
    (command.ForEach
      iter_names: [r]
      iterable: 
        (for_iter.Words
          words: [
            {
              (DQ 
                (braced_var_sub
                  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
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: 
                    (sh_lhs_expr.IndexedName
                      left: <Id.Lit_ArrayLhsOpen 'flags['>
                      name: flags
                      index: 
                        {
                          (braced_var_sub
                            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: []
            )
          ]
        )
      redirects: []
    )
    (C {<argv>} 
      {
        (DQ 
          (braced_var_sub
            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 '}'>
          )
        )
      }
    )
    (C {<shopt>} {<-s>} {<simple_word_eval>} {<parse_at>})
    (command.VarDecl
      keyword: <Id.KW_Var var>
      lhs: [(name_type name:<Id.Expr_Name regex2>)]
      rhs: (sh_array_literal left:<Id.Left_PercentParen '%('> words:[{<new1>} {<new2>}])
    )
    (command.VarDecl
      keyword: <Id.KW_Var var>
      lhs: [(name_type name:<Id.Expr_Name flags2>)]
      rhs: (sh_array_literal left:<Id.Left_PercentParen '%('> words:[])
    )
    (command.ForEach
      iter_names: [r]
      iterable: (for_iter.Words words:[{<Id.Lit_Splice '@regex2'>}])
      body: 
        (command.DoGroup
          children: [
            (C {<append>} {<Id.Lit_Colon ':'> <flags2>} {(DQ <'--regex='> ($ Id.VSub_DollarName r))})
          ]
        )
      redirects: []
    )
    (C {<argv>} {<Id.Lit_Splice '@flags2'>})
  ]
)
(command.CommandList
  children: [
    (C {<echo>} {(SQ <'This is a shell script with OSH extensions!'>)})
    (C {<echo>})
    (command.VarDecl
      keyword: <Id.KW_Var var>
      lhs: [(name_type name:<Id.Expr_Name x>)]
      rhs: 
        (expr.Binary
          op: <Id.Arith_Plus _>
          left: (Const Id.Expr_DecInt 1)
          right: 
            (expr.Binary
              op: <Id.Arith_Star _>
              left: (Const Id.Expr_DecInt 2)
              right: (Const Id.Expr_DecInt 3)
            )
        )
    )
    (C {<echo>} {(DQ <'x: '> ($ Id.VSub_DollarName x))})
    (command.PlaceMutation
      keyword: <Id.KW_SetVar setvar>
      lhs: [(place_expr.Var name:<Id.Expr_Name x>)]
      op: <Id.Arith_PlusEqual _>
      rhs: (Const Id.Expr_DecInt 1)
    )
    (C {<echo>} {(DQ <'x: '> ($ Id.VSub_DollarName x))})
    (command.VarDecl
      keyword: <Id.KW_Var var>
      lhs: [(name_type name:<Id.Expr_Name mylist>)]
      rhs: 
        (expr.List
          elts: [(Const Id.Expr_DecInt 1) (Const Id.Expr_DecInt 2) (Const Id.Expr_DecInt 3)]
          ctx: expr_context.Store
        )
    )
    (command.VarDecl
      keyword: <Id.KW_Var var>
      lhs: [(name_type name:<Id.Expr_Name y>)]
      rhs: 
        (expr.Binary
          op: <Id.Arith_Star _>
          left: (subscript obj:(Var mylist) indices:[(Const Id.Expr_DecInt 1)])
          right: (Const Id.Expr_DecInt 10)
        )
    )
    (C {<echo>} {(DQ <'y: '> ($ Id.VSub_DollarName y))})
    (command.VarDecl
      keyword: <Id.KW_Var var>
      lhs: [(name_type name:<Id.Expr_Name list2>)]
      rhs: 
        (expr.Binary
          op: <Id.Arith_DPlus _>
          left: (Var mylist)
          right: 
            (expr.List
              elts: [(Const Id.Expr_DecInt 4) (Const Id.Expr_DecInt 5)]
              ctx: expr_context.Store
            )
        )
    )
    (C {<pp>} {<cell>} {<list2>})
    (command.ShAssignment
      pairs: [
        (assign_pair
          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: [(name_type name:<Id.Expr_Name str2>)]
      rhs: (DQ <'Oil string'>)
    )
    (command.VarDecl
      keyword: <Id.KW_Var var>
      lhs: [(name_type name:<Id.Expr_Name str3>)]
      rhs: (expr.Binary op:<Id.Arith_DPlus _> left:(Var str1) right:(Var str2))
    )
    (C {<echo>} {(DQ <'str3 = '> ($ Id.VSub_DollarName str3))})
  ]
)
(command.CommandList
  children: [
    (command.ShFunction
      name: argv
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (C {<python>} {<-c>} {(SQ <'import sys;print(sys.argv[1:])'>)} {<Id.Lit_Splice '@ARGV'>})
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name: show
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [(C {<echo>} {(SQ <'====='>)}) (C {<argv>} {<Id.Lit_Splice '@ARGV'>}) (C {<echo>})]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.VarDecl
      keyword: <Id.KW_Var var>
      lhs: [(name_type name:<Id.Expr_Name strarray>)]
      rhs: 
        (sh_array_literal
          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 '> 
                (braced_var_sub
                  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 '}'>
                )
              )
            }
          ]
        )
    )
    (C {<show>} {<Id.Lit_Splice '@strarray'>})
    (command.VarDecl
      keyword: <Id.KW_Var var>
      lhs: [(name_type name:<Id.Expr_Name cmd_sub>)]
      rhs: 
        (command_sub
          left_token: <Id.Left_DollarParen '$('>
          child: 
            (C {<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 '> 
                  (braced_var_sub
                    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 '}'>
                  )
                )
              }
            )
          right: <Id.Eof_RParen _>
        )
    )
    (C {<show>} {($ Id.VSub_DollarName cmd_sub)})
    (C {<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 '> 
                      (braced_var_sub
                        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.CommandList
  children: [
    (C {<echo>} 
      {
        (single_quoted
          left: <Id.Left_DollarSingleQuote '$\''>
          tokens: [<Id.Char_Literals one> <Id.Char_OneChar '\\n'> <Id.Char_Literals two>]
          right: <Id.Right_SingleQuote '\''>
        )
      }
    )
    (command.VarDecl
      keyword: <Id.KW_Var var>
      lhs: [(name_type name:<Id.Expr_Name a>)]
      rhs: 
        (expr.Binary
          op: <Id.Arith_Plus _>
          left: (Const Id.Expr_DecInt 1)
          right: 
            (expr.Binary
              op: <Id.Arith_Star _>
              left: (Const Id.Expr_DecInt 2)
              right: (Const Id.Expr_DecInt 3)
            )
        )
    )
    (C {<echo>} {<Id.Lit_VarLike 'a='> ($ Id.VSub_DollarName a)})
    (command.VarDecl
      keyword: <Id.KW_Var var>
      lhs: [(name_type name:<Id.Expr_Name b>)]
      rhs: 
        (expr.Binary
          op: <Id.Arith_Slash _>
          left: (Const Id.Expr_DecInt 5)
          right: (Const Id.Expr_DecInt 6)
        )
    )
    (C {<echo>} {<Id.Lit_VarLike 'b='> ($ Id.VSub_DollarName b)})
    (C {<echo>} {<hi>})
    (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: (Var b)
            )
          terminator: <Id.Op_Semi _>
        )
        (C {<echo>} {<hi>})
      ]
    )
    (command.PlaceMutation
      keyword: <Id.KW_SetVar setvar>
      lhs: [(place_expr.Var name:<Id.Expr_Name x>)]
      op: <Id.Arith_Equal _>
      rhs: (Const 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: (Const Id.Expr_DecInt 1)
    )
    (command.VarDecl
      keyword: <Id.KW_Var var>
      lhs: [(name_type name:<Id.Expr_Name y>) (name_type name:<Id.Expr_Name z>)]
      rhs: (expr.Tuple elts:[(Var a) (Var b)] ctx:expr_context.Store)
    )
    (C {<echo>} {<hi>})
    (command.VarDecl
      keyword: <Id.KW_Var var>
      lhs: [(name_type name:<Id.Expr_Name mycmd>)]
      rhs: 
        (expr.Binary
          op: <Id.Arith_Plus _>
          left: 
            (command_sub
              left_token: <Id.Left_DollarParen '$('>
              child: (C {<echo>} {<cmd>})
              right: <Id.Eof_RParen _>
            )
          right: 
            (DQ 
              (command_sub
                left_token: <Id.Left_DollarParen '$('>
                child: (C {<echo>} {<cmd>})
                right: <Id.Eof_RParen _>
              )
            )
        )
    )
    (C {<echo>} {<Id.Lit_VarLike 'mycmd='> ($ Id.VSub_DollarName mycmd)})
    (command.VarDecl
      keyword: <Id.KW_Var var>
      lhs: [(name_type name:<Id.Expr_Name mybrace>)]
      rhs: (expr.Binary op:<Id.Arith_Plus _> left:(${ Id.VSub_Name b) right:(DQ (${ Id.VSub_Name b)))
    )
    (C {<echo>} {<Id.Lit_VarLike 'mybrace='> ($ Id.VSub_DollarName mybrace)})
    (command.VarDecl
      keyword: <Id.KW_Var var>
      lhs: [(name_type name:<Id.Expr_Name paren>)]
      rhs: 
        (expr.Binary
          op: <Id.Arith_Star _>
          left: 
            (expr.Binary
              op: <Id.Arith_Plus _>
              left: (Const Id.Expr_DecInt 1)
              right: (Const Id.Expr_DecInt 2)
            )
          right: (Const Id.Expr_DecInt 3)
        )
    )
    (C {<echo>} {<Id.Lit_VarLike 'paren='> ($ Id.VSub_DollarName paren)})
    (command.VarDecl
      keyword: <Id.KW_Var var>
      lhs: [(name_type name:<Id.Expr_Name line_cont>)]
      rhs: 
        (expr.Binary
          op: <Id.Arith_Plus _>
          left: (Const Id.Expr_DecInt 4)
          right: (Const Id.Expr_DecInt 5)
        )
    )
    (C {<echo>} {<Id.Lit_VarLike 'line_cont='> ($ Id.VSub_DollarName line_cont)})
    (command.VarDecl
      keyword: <Id.KW_Var var>
      lhs: [(name_type name:<Id.Expr_Name multiline>)]
      rhs: 
        (expr.Binary
          op: <Id.Arith_Plus _>
          left: (Const Id.Expr_DecInt 6)
          right: (Const Id.Expr_DecInt 7)
        )
    )
    (C {<echo>} {<Id.Lit_VarLike 'multiline='> ($ Id.VSub_DollarName multiline)})
    (command.VarDecl
      keyword: <Id.KW_Var var>
      lhs: [(name_type name:<Id.Expr_Name aug>)]
      rhs: (Const 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: (Const Id.Expr_DecInt 9)
    )
    (C {<echo>} {<Id.Lit_VarLike 'aug='> ($ Id.VSub_DollarName aug)})
  ]
)
(command.CommandList
  children: [
    (command.ShFunction
      name: argv
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.Sentence
              child: (C {<'spec/bin/argv.py'>} {(DQ ($ Id.VSub_At '@'))})
              terminator: <Id.Op_Semi _>
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          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: [
        (assign_pair
          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: [
        (assign_pair
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'flags='> name:flags)
          op: assign_op.Equal
          rhs: {(SQ )}
          spids: [56]
        )
      ]
      redirects: []
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Sentence
                  child: 
                    (C {<Id.Lit_LBracket '['>} {<-n>} {(DQ (${ Id.VSub_Name CONFIG_HAVE_FOO))} 
                      {<Id.Lit_RBracket ']'>}
                    )
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          action: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  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: []
      redirects: []
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Sentence
                  child: 
                    (C {<Id.Lit_LBracket '['>} {<-n>} {(DQ (${ Id.VSub_Name CONFIG_HAVE_BAR))} 
                      {<Id.Lit_RBracket ']'>}
                    )
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          action: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  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: []
      redirects: []
    )
    (C {<argv>} {(${ Id.VSub_Name flags)})
    (C {<set>} {<-o>} {<errexit>})
    (C {<shopt>} {<-s>} {<parse_at>} {<simple_word_eval>})
    (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: (sh_array_literal left:<Id.Left_PercentParen '%('> words:[])
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Sentence
                  child: (C {<test>} {<-n>} {($ Id.VSub_DollarName CONFIG_HAVE_FOO)})
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          action: [
            (C {<append>} {<Id.Lit_Colon ':'> <flags>} 
              {<--foo> <Id.Lit_Equals '='> ($ Id.VSub_DollarName path)}
            )
          ]
          spids: [204 213]
        )
      ]
      else_action: []
      redirects: []
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Sentence
                  child: (C {<test>} {<-n>} {($ Id.VSub_DollarName CONFIG_HAVE_BAR)})
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          action: [(C {<append>} {<Id.Lit_Colon ':'> <flags>} {<--bar>})]
          spids: [228 237]
        )
      ]
      else_action: []
      redirects: []
    )
    (C {<argv>} {<Id.Lit_Splice '@flags'>})
  ]
)
(command.CommandList
  children: [
    (command.ShAssignment
      pairs: [
        (assign_pair
          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: [
            (C {<local>} {<Id.Lit_VarLike 'g_var='> <f>})
            (C {<echo>} {($ Id.VSub_DollarName g_var)})
            (C {<echo>} {($ Id.VSub_DollarName f_var)})
            (command.VarDecl
              keyword: <Id.KW_Var var>
              lhs: [(name_type name:<Id.Expr_Name oil_var>)]
              rhs: (Var global_var)
            )
            (C {<echo>} {($ Id.VSub_DollarName oil_var)})
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name: f
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (C {<local>} {<Id.Lit_VarLike 'f_var='> <f>})
            (C {<echo>} {($ Id.VSub_DollarName f_var)})
            (C {<g>})
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (C {<f>})
  ]
)
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-03-08
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.