*** Running test-parse-osh
---
(command.CommandList
  children: [
    (command.Simple
      blame_tok: <shopt>
      more_env: []
      words: [{<shopt>} {<-s>} {<oil-parse-at>} {<static-word-eval>}]
      redirects: []
      do_fork: T
    )
    (command.ShAssignment
      left: <Id.Lit_VarLike "myglobal=">
      pairs: [
        (AssignPair
          left: <Id.Lit_VarLike "myglobal=">
          lhs: (sh_lhs.Name left:<Id.Lit_VarLike "myglobal="> name:myglobal)
          op: assign_op.Equal
          rhs: {<global>}
        )
      ]
      redirects: []
    )
    (command.VarDecl
      keyword: <Id.KW_Var var>
      lhs: [(NameType name:<Id.Expr_Name myarray>)]
      rhs: 
        (ShArrayLiteral
          left: <Id.Left_ColonPipe ":|">
          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 "}">
              )
            }
          ]
          right: <Id.Op_Pipe _>
        )
    )
    (command.Simple
      blame_tok: <spec/bin/argv.py>
      more_env: []
      words: [{<spec/bin/argv.py>} {<Id.Lit_Splice "@myarray">}]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <echo>
      more_env: []
      words: [
        {<echo>}
        {<Id.Lit_VarLike "len="> 
          (word_part.ExprSub
            left: <Id.Left_DollarBracket "$[">
            child: 
              (expr.FuncCall
                func: (expr.Var name:<Id.Expr_Name len>)
                args: 
                  (ArgList
                    left: <Id.Op_LParen _>
                    pos_args: [(expr.Var name:<Id.Expr_Name myarray>)]
                    named_args: []
                    right: <Id.Op_RParen _>
                  )
              )
            right: <Id.Op_RBracket _>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple blame_tok:<echo> more_env:[] words:[{<echo>}] redirects:[] do_fork:T)
    (command.Simple
      blame_tok: <append>
      more_env: []
      words: [
        {<append>}
        {<myarray>}
        {<_>}
        {(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: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <spec/bin/argv.py>
      more_env: []
      words: [{<spec/bin/argv.py>} {<Id.Lit_Splice "@myarray">}]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <echo>
      more_env: []
      words: [
        {<echo>}
        {<Id.Lit_VarLike "len="> 
          (word_part.ExprSub
            left: <Id.Left_DollarBracket "$[">
            child: 
              (expr.FuncCall
                func: (expr.Var name:<Id.Expr_Name len>)
                args: 
                  (ArgList
                    left: <Id.Op_LParen _>
                    pos_args: [(expr.Var name:<Id.Expr_Name myarray>)]
                    named_args: []
                    right: <Id.Op_RParen _>
                  )
              )
            right: <Id.Op_RBracket _>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
    (command.Simple blame_tok:<echo> more_env:[] words:[{<echo>}] redirects:[] do_fork:T)
    (command.ForEach
      keyword: <Id.KW_For for>
      iter_names: [item]
      iterable: (for_iter.YshExpr e:(expr.Var name:<Id.Expr_Name myarray>) blame:<Id.KW_In in>)
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace "{">
          children: [
            (command.Simple
              blame_tok: <echo>
              more_env: []
              words: [{<echo>} {(DQ <"  "> ($ Id.VSub_DollarName item))}]
              redirects: []
              do_fork: T
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace "}">
        )
      redirects: []
    )
  ]
)
---
(command.CommandList
  children: [
    (command.ShFunction
      name_tok: <argv>
      name: argv
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace "{">
          children: [
            (command.Sentence
              child: 
                (command.Simple
                  blame_tok: <spec/bin/argv.py>
                  more_env: []
                  words: [{<spec/bin/argv.py>} {(DQ ($ Id.VSub_At "@"))}]
                  redirects: []
                  do_fork: T
                )
              terminator: <Id.Op_Semi _>
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace "}">
        )
    )
    (command.ShAssignment
      left: <Id.Lit_VarLike "regex=">
      pairs: [
        (AssignPair
          left: <Id.Lit_VarLike "regex=">
          lhs: (sh_lhs.Name left:<Id.Lit_VarLike "regex="> name:regex)
          op: assign_op.Equal
          rhs: 
            {
              (ShArrayLiteral
                left: <Id.Op_LParen _>
                words: [{<old1>} {<old2>}]
                right: <Id.Right_ShArrayLiteral _>
              )
            }
        )
      ]
      redirects: []
    )
    (command.ShAssignment
      left: <Id.Lit_VarLike "flags=">
      pairs: [
        (AssignPair
          left: <Id.Lit_VarLike "flags=">
          lhs: (sh_lhs.Name left:<Id.Lit_VarLike "flags="> name:flags)
          op: assign_op.Equal
          rhs: {(ShArrayLiteral left:<Id.Op_LParen _> words:[] right:<Id.Right_ShArrayLiteral _>)}
        )
      ]
      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 "}">
                )
              )
            }
          ]
        )
      semi_tok: <Id.Op_Semi _>
      body: 
        (command.DoGroup
          left: <Id.KW_Do do>
          children: [
            (command.ShAssignment
              left: <Id.Lit_ArrayLhsOpen "flags[">
              pairs: [
                (AssignPair
                  left: <Id.Lit_ArrayLhsOpen "flags[">
                  lhs: 
                    (sh_lhs.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))}
                )
              ]
              redirects: []
            )
          ]
          right: <Id.KW_Done done>
        )
      redirects: []
    )
    (command.Simple
      blame_tok: <argv>
      more_env: []
      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: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <shopt>
      more_env: []
      words: [{<shopt>} {<-s>} {<simple_word_eval>} {<parse_at>}]
      redirects: []
      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>}]
          right: <Id.Right_ShArrayLiteral _>
        )
    )
    (command.VarDecl
      keyword: <Id.KW_Var var>
      lhs: [(NameType name:<Id.Expr_Name flags2>)]
      rhs: 
        (ShArrayLiteral
          left: <Id.Left_PercentParen "%(">
          words: []
          right: <Id.Right_ShArrayLiteral _>
        )
    )
    (command.ForEach
      keyword: <Id.KW_For for>
      iter_names: [r]
      iterable: (for_iter.Words words:[{<Id.Lit_Splice "@regex2">}])
      semi_tok: <Id.Op_Semi _>
      body: 
        (command.DoGroup
          left: <Id.KW_Do do>
          children: [
            (command.Simple
              blame_tok: <append>
              more_env: []
              words: [
                {<append>}
                {<Id.Lit_Colon ":"> <flags2>}
                {(DQ <"--regex="> ($ Id.VSub_DollarName r))}
              ]
              redirects: []
              do_fork: T
            )
          ]
          right: <Id.KW_Done done>
        )
      redirects: []
    )
    (command.Simple
      blame_tok: <argv>
      more_env: []
      words: [{<argv>} {<Id.Lit_Splice "@flags2">}]
      redirects: []
      do_fork: T
    )
  ]
)
---
(command.CommandList
  children: [
    (command.Simple
      blame_tok: <echo>
      more_env: []
      words: [{<echo>} {(SQ <"This is a shell script with OSH extensions!">)}]
      redirects: []
      do_fork: T
    )
    (command.Simple blame_tok:<echo> more_env:[] words:[{<echo>}] redirects:[] 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
      blame_tok: <echo>
      more_env: []
      words: [{<echo>} {(DQ <"x: "> ($ Id.VSub_DollarName x))}]
      redirects: []
      do_fork: T
    )
    (command.Mutation
      keyword: <Id.KW_SetVar setvar>
      lhs: [(y_lhs.Var name:<Id.Expr_Name x>)]
      op: <Id.Arith_PlusEqual _>
      rhs: (expr.Const c:<Id.Expr_DecInt 1>)
    )
    (command.Simple
      blame_tok: <echo>
      more_env: []
      words: [{<echo>} {(DQ <"x: "> ($ Id.VSub_DollarName x))}]
      redirects: []
      do_fork: T
    )
    (command.VarDecl
      keyword: <Id.KW_Var var>
      lhs: [(NameType name:<Id.Expr_Name mylist>)]
      rhs: 
        (expr.List
          left: <Id.Op_LBracket _>
          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
              left: <Id.Op_LBracket _>
              obj: (expr.Var name:<Id.Expr_Name mylist>)
              index: (expr.Const c:<Id.Expr_DecInt 1>)
            )
          right: (expr.Const c:<Id.Expr_DecInt 10>)
        )
    )
    (command.Simple
      blame_tok: <echo>
      more_env: []
      words: [{<echo>} {(DQ <"y: "> ($ Id.VSub_DollarName y))}]
      redirects: []
      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
              left: <Id.Op_LBracket _>
              elts: [(expr.Const c:<Id.Expr_DecInt 4>) (expr.Const c:<Id.Expr_DecInt 5>)]
              ctx: expr_context.Store
            )
        )
    )
    (command.Simple
      blame_tok: <pp>
      more_env: []
      words: [{<pp>} {<cell>} {<list2>}]
      redirects: []
      do_fork: T
    )
    (command.ShAssignment
      left: <Id.Lit_VarLike "str1=">
      pairs: [
        (AssignPair
          left: <Id.Lit_VarLike "str1=">
          lhs: (sh_lhs.Name left:<Id.Lit_VarLike "str1="> name:str1)
          op: assign_op.Equal
          rhs: {(SQ <"shell string">)}
        )
      ]
      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
      blame_tok: <echo>
      more_env: []
      words: [{<echo>} {(DQ <"str3 = "> ($ Id.VSub_DollarName str3))}]
      redirects: []
      do_fork: T
    )
  ]
)
---
(command.CommandList
  children: [
    (command.ShFunction
      name_tok: <argv>
      name: argv
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace "{">
          children: [
            (command.Simple
              blame_tok: <python>
              more_env: []
              words: [
                {<python>}
                {<-c>}
                {(SQ <"import sys;print(sys.argv[1:])">)}
                {<Id.Lit_Splice "@ARGV">}
              ]
              redirects: []
              do_fork: T
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace "}">
        )
    )
    (command.ShFunction
      name_tok: <show>
      name: show
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace "{">
          children: [
            (command.Simple
              blame_tok: <echo>
              more_env: []
              words: [{<echo>} {(SQ <"=====">)}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <argv>
              more_env: []
              words: [{<argv>} {<Id.Lit_Splice "@ARGV">}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <echo>
              more_env: []
              words: [{<echo>}]
              redirects: []
              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 "}">
                )
              )
            }
          ]
          right: <Id.Right_ShArrayLiteral _>
        )
    )
    (command.Simple
      blame_tok: <show>
      more_env: []
      words: [{<show>} {<Id.Lit_Splice "@strarray">}]
      redirects: []
      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
              blame_tok: <echo>
              more_env: []
              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: []
              do_fork: T
            )
          right: <Id.Eof_RParen _>
        )
    )
    (command.Simple
      blame_tok: <show>
      more_env: []
      words: [{<show>} {($ Id.VSub_DollarName cmd_sub)}]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <show>
      more_env: []
      words: [
        {<show>}
        {
          (word_part.ExprSub
            left: <Id.Left_DollarBracket "$[">
            child: 
              (expr.Binary
                op: <Id.Arith_DPlus _>
                left: (expr.Binary op:<Id.Arith_DPlus _> left:(SQ <"quoted ">) right:(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 "}">
                    )
                  )
              )
            right: <Id.Op_RBracket _>
          )
        }
      ]
      redirects: []
      do_fork: T
    )
  ]
)
---
(command.CommandList
  children: [
    (command.Simple
      blame_tok: <echo>
      more_env: []
      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: []
      do_fork: T
    )
    (command.VarDecl
      keyword: <Id.KW_Var var>
      lhs: [(NameType name:<Id.Expr_Name a> typ:(TypeExpr tok:<Id.Expr_Name Int> name:Int))]
      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
      blame_tok: <echo>
      more_env: []
      words: [{<echo>} {<Id.Lit_VarLike "a="> ($ Id.VSub_DollarName a)}]
      redirects: []
      do_fork: T
    )
    (command.VarDecl
      keyword: <Id.KW_Var var>
      lhs: [(NameType name:<Id.Expr_Name b> typ:(TypeExpr tok:<Id.Expr_Name Float> name:Float))]
      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
      blame_tok: <echo>
      more_env: []
      words: [{<echo>} {<Id.Lit_VarLike "b="> ($ Id.VSub_DollarName b)}]
      redirects: []
      do_fork: T
    )
    (command.Simple blame_tok:<echo> more_env:[] words:[{<echo>} {<hi>}] redirects:[] do_fork:T)
    (command.CommandList
      children: [
        (command.Sentence
          child: 
            (command.Mutation
              keyword: <Id.KW_SetVar setvar>
              lhs: [(y_lhs.Var name:<Id.Expr_Name a>)]
              op: <Id.Arith_Equal _>
              rhs: (expr.Var name:<Id.Expr_Name b>)
            )
          terminator: <Id.Op_Semi _>
        )
        (command.Simple
          blame_tok: <echo>
          more_env: []
          words: [{<echo>} {<hi>}]
          redirects: []
          do_fork: T
        )
      ]
    )
    (command.Mutation
      keyword: <Id.KW_SetVar setvar>
      lhs: [(y_lhs.Var name:<Id.Expr_Name x>)]
      op: <Id.Arith_Equal _>
      rhs: (expr.Const c:<Id.Expr_DecInt 4>)
    )
    (command.Mutation
      keyword: <Id.KW_SetVar setvar>
      lhs: [(y_lhs.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>)]
      rhs: (expr.Var name:<Id.Expr_Name a>)
    )
    (command.VarDecl
      keyword: <Id.KW_Var var>
      lhs: [(NameType name:<Id.Expr_Name z>)]
      rhs: (expr.Var name:<Id.Expr_Name b>)
    )
    (command.Simple blame_tok:<echo> more_env:[] words:[{<echo>} {<hi>}] redirects:[] 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
                  blame_tok: <echo>
                  more_env: []
                  words: [{<echo>} {<cmd>}]
                  redirects: []
                  do_fork: T
                )
              right: <Id.Eof_RParen _>
            )
          right: 
            (DQ 
              (CommandSub
                left_token: <Id.Left_DollarParen "$(">
                child: 
                  (command.Simple
                    blame_tok: <echo>
                    more_env: []
                    words: [{<echo>} {<cmd>}]
                    redirects: []
                    do_fork: T
                  )
                right: <Id.Eof_RParen _>
              )
            )
        )
    )
    (command.Simple
      blame_tok: <echo>
      more_env: []
      words: [{<echo>} {<Id.Lit_VarLike "mycmd="> ($ Id.VSub_DollarName mycmd)}]
      redirects: []
      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
      blame_tok: <echo>
      more_env: []
      words: [{<echo>} {<Id.Lit_VarLike "mybrace="> ($ Id.VSub_DollarName mybrace)}]
      redirects: []
      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
      blame_tok: <echo>
      more_env: []
      words: [{<echo>} {<Id.Lit_VarLike "paren="> ($ Id.VSub_DollarName paren)}]
      redirects: []
      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
      blame_tok: <echo>
      more_env: []
      words: [{<echo>} {<Id.Lit_VarLike "line_cont="> ($ Id.VSub_DollarName line_cont)}]
      redirects: []
      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
      blame_tok: <echo>
      more_env: []
      words: [{<echo>} {<Id.Lit_VarLike "multiline="> ($ Id.VSub_DollarName multiline)}]
      redirects: []
      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.Mutation
      keyword: <Id.KW_SetVar setvar>
      lhs: [(y_lhs.Var name:<Id.Expr_Name aug>)]
      op: <Id.Arith_PlusEqual _>
      rhs: (expr.Const c:<Id.Expr_DecInt 9>)
    )
    (command.Simple
      blame_tok: <echo>
      more_env: []
      words: [{<echo>} {<Id.Lit_VarLike "aug="> ($ Id.VSub_DollarName aug)}]
      redirects: []
      do_fork: T
    )
  ]
)
---
(command.CommandList
  children: [
    (command.ShFunction
      name_tok: <argv>
      name: argv
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace "{">
          children: [
            (command.Sentence
              child: 
                (command.Simple
                  blame_tok: <spec/bin/argv.py>
                  more_env: []
                  words: [{<spec/bin/argv.py>} {(DQ ($ Id.VSub_At "@"))}]
                  redirects: []
                  do_fork: T
                )
              terminator: <Id.Op_Semi _>
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace "}">
        )
    )
    (command.ShAssignment
      left: <Id.Lit_VarLike "CONFIG_HAVE_FOO=">
      pairs: [
        (AssignPair
          left: <Id.Lit_VarLike "CONFIG_HAVE_FOO=">
          lhs: (sh_lhs.Name left:<Id.Lit_VarLike "CONFIG_HAVE_FOO="> name:CONFIG_HAVE_FOO)
          op: assign_op.Equal
          rhs: {<yes>}
        )
      ]
      redirects: []
    )
    (command.ShAssignment
      left: <Id.Lit_VarLike "path=">
      pairs: [
        (AssignPair
          left: <Id.Lit_VarLike "path=">
          lhs: (sh_lhs.Name left:<Id.Lit_VarLike "path="> name:path)
          op: assign_op.Equal
          rhs: {(SQ <"/etc/path with spaces">)}
        )
      ]
      redirects: []
    )
    (command.ShAssignment
      left: <Id.Lit_VarLike "flags=">
      pairs: [
        (AssignPair
          left: <Id.Lit_VarLike "flags=">
          lhs: (sh_lhs.Name left:<Id.Lit_VarLike "flags="> name:flags)
          op: assign_op.Equal
          rhs: {(SQ )}
        )
      ]
      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
                      blame_tok: <Id.Lit_LBracket "[">
                      more_env: []
                      words: [
                        {<Id.Lit_LBracket "[">}
                        {<-n>}
                        {(DQ (${ Id.VSub_Name CONFIG_HAVE_FOO))}
                        {<Id.Lit_RBracket "]">}
                      ]
                      redirects: []
                      do_fork: T
                    )
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          then_kw: <Id.KW_Then then>
          action: [
            (command.ShAssignment
              left: <Id.Lit_VarLike "flags=">
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike "flags=">
                  lhs: (sh_lhs.Name left:<Id.Lit_VarLike "flags="> name:flags)
                  op: assign_op.Equal
                  rhs: {(DQ (${ Id.VSub_Name flags) <" --foo="> ($ Id.VSub_DollarName path))}
                )
              ]
              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
                      blame_tok: <Id.Lit_LBracket "[">
                      more_env: []
                      words: [
                        {<Id.Lit_LBracket "[">}
                        {<-n>}
                        {(DQ (${ Id.VSub_Name CONFIG_HAVE_BAR))}
                        {<Id.Lit_RBracket "]">}
                      ]
                      redirects: []
                      do_fork: T
                    )
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          then_kw: <Id.KW_Then then>
          action: [
            (command.ShAssignment
              left: <Id.Lit_VarLike "flags=">
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike "flags=">
                  lhs: (sh_lhs.Name left:<Id.Lit_VarLike "flags="> name:flags)
                  op: assign_op.Equal
                  rhs: {(DQ (${ Id.VSub_Name flags) <" --bar">)}
                )
              ]
              redirects: []
            )
          ]
          spids: [92 107]
        )
      ]
      else_action: []
      fi_kw: <Id.KW_Fi fi>
      redirects: []
    )
    (command.Simple
      blame_tok: <argv>
      more_env: []
      words: [{<argv>} {(${ Id.VSub_Name flags)}]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <set>
      more_env: []
      words: [{<set>} {<-o>} {<errexit>}]
      redirects: []
      do_fork: T
    )
    (command.Simple
      blame_tok: <shopt>
      more_env: []
      words: [{<shopt>} {<-s>} {<parse_at>} {<simple_word_eval>}]
      redirects: []
      do_fork: T
    )
    (command.Mutation
      keyword: <Id.KW_SetVar setvar>
      lhs: [(y_lhs.Var name:<Id.Expr_Name CONFIG_HAVE_FOO>)]
      op: <Id.Arith_Equal _>
      rhs: (DQ <yes>)
    )
    (command.Mutation
      keyword: <Id.KW_SetVar setvar>
      lhs: [(y_lhs.Var name:<Id.Expr_Name path>)]
      op: <Id.Arith_Equal _>
      rhs: (DQ <"/etc/path with spaces">)
    )
    (command.Mutation
      keyword: <Id.KW_SetVar setvar>
      lhs: [(y_lhs.Var name:<Id.Expr_Name flags>)]
      op: <Id.Arith_Equal _>
      rhs: 
        (ShArrayLiteral
          left: <Id.Left_PercentParen "%(">
          words: []
          right: <Id.Right_ShArrayLiteral _>
        )
    )
    (command.If
      if_kw: <Id.KW_If if>
      arms: [
        (IfArm
          keyword: <Id.KW_If if>
          cond: 
            (condition.Shell
              commands: [
                (command.Sentence
                  child: 
                    (command.Simple
                      blame_tok: <test>
                      more_env: []
                      words: [{<test>} {<-n>} {($ Id.VSub_DollarName CONFIG_HAVE_FOO)}]
                      redirects: []
                      do_fork: T
                    )
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          then_kw: <Id.KW_Then then>
          action: [
            (command.Simple
              blame_tok: <append>
              more_env: []
              words: [{<append>} {<-->} {<--foo> <Id.Lit_Equals "="> ($ Id.VSub_DollarName path)}]
              redirects: []
              typed_args: 
                (ArgList
                  left: <Id.Op_LParen _>
                  pos_args: [(expr.Var name:<Id.Expr_Name flags>)]
                  named_args: []
                  right: <Id.Op_RParen _>
                )
              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
                      blame_tok: <test>
                      more_env: []
                      words: [{<test>} {<-n>} {($ Id.VSub_DollarName CONFIG_HAVE_BAR)}]
                      redirects: []
                      do_fork: T
                    )
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          then_kw: <Id.KW_Then then>
          action: [
            (command.Simple
              blame_tok: <append>
              more_env: []
              words: [{<append>} {<-->} {<--bar>}]
              redirects: []
              typed_args: 
                (ArgList
                  left: <Id.Op_LParen _>
                  pos_args: [(expr.Var name:<Id.Expr_Name flags>)]
                  named_args: []
                  right: <Id.Op_RParen _>
                )
              do_fork: T
            )
          ]
          spids: [231 240]
        )
      ]
      else_action: []
      fi_kw: <Id.KW_Fi fi>
      redirects: []
    )
    (command.Simple
      blame_tok: <argv>
      more_env: []
      words: [{<argv>} {<Id.Lit_Splice "@flags">}]
      redirects: []
      do_fork: T
    )
  ]
)
---
(command.CommandList
  children: [
    (command.ShAssignment
      left: <Id.Lit_VarLike "global_var=">
      pairs: [
        (AssignPair
          left: <Id.Lit_VarLike "global_var=">
          lhs: (sh_lhs.Name left:<Id.Lit_VarLike "global_var="> name:global_var)
          op: assign_op.Equal
          rhs: {<global>}
        )
      ]
      redirects: []
    )
    (command.ShFunction
      name_tok: <g>
      name: g
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace "{">
          children: [
            (command.Simple
              blame_tok: <local>
              more_env: []
              words: [{<local>} {<Id.Lit_VarLike "g_var="> <f>}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <echo>
              more_env: []
              words: [{<echo>} {($ Id.VSub_DollarName g_var)}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <echo>
              more_env: []
              words: [{<echo>} {($ Id.VSub_DollarName f_var)}]
              redirects: []
              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
              blame_tok: <echo>
              more_env: []
              words: [{<echo>} {($ Id.VSub_DollarName oil_var)}]
              redirects: []
              do_fork: T
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace "}">
        )
    )
    (command.ShFunction
      name_tok: <f>
      name: f
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace "{">
          children: [
            (command.Simple
              blame_tok: <local>
              more_env: []
              words: [{<local>} {<Id.Lit_VarLike "f_var="> <f>}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <echo>
              more_env: []
              words: [{<echo>} {($ Id.VSub_DollarName f_var)}]
              redirects: []
              do_fork: T
            )
            (command.Simple
              blame_tok: <g>
              more_env: []
              words: [{<g>}]
              redirects: []
              do_fork: T
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace "}">
        )
    )
    (command.Simple blame_tok:<f> more_env:[] words:[{<f>}] redirects:[] do_fork:T)
  ]
)
OK  test-parse-osh
*** Running test-run-osh
ysh/testdata/array-rewrite-1.sh
---
['--regex=old1', '--regex=old2']
    append :flags2 "--regex=$r"
    ^~~~~~
ysh/testdata/array-rewrite-1.sh:40: 'append' expected a List as a typed arg
    append :flags2 "--regex=$r"
    ^~~~~~
ysh/testdata/array-rewrite-1.sh:40: 'append' expected a List as a typed arg
[]
ysh/testdata/array-rewrite-2.sh
---
['--foo=/etc/path', 'with', 'spaces']
['--foo=/etc/path with spaces']
ysh/testdata/sigil-pairs.sh
---
=====
['@ARGV']

=====
['@ARGV']

=====
['@ARGV']

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

  append myarray _ '1 2' ${myglobal:-default}
  ^~~~~~
ysh/testdata/array-splice-demo.osh:11: 'append' expected a List as a typed arg
['@myarray']
len=3

  global
  line

  default
ysh/testdata/assign.osh
skipping ysh/testdata/assign.osh
ysh/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.List
      items: [(value.Int i:1) (value.Int i:2) (value.Int i:3) (value.Int i:4) (value.Int i:5)]
    )
)
str3 = shell stringOil string
ysh/testdata/no-dynamic-scope.osh
skipping ysh/testdata/no-dynamic-scope.osh
OK  test-run-osh
*** Running test-run-ysh
---
+ 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 Dict->reverse() method is from Python.

hello
world

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 42
---
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


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
failure
2024
Here I am!
could be anything really
date: unrecognized option '--wrong-flag'
Try 'date --help' for more information.
there was an error
number
2024-02-04
2024
OK  test-run-ysh

ysh/run.sh: 3 tests passed.