RUN asdl/examples/typed_arith_parse_test.py > _test/py-unit/asdl/examples/typed_arith_parse_test.py.log
OK
RUN asdl/format_test.py > _test/py-unit/asdl/format_test.py.log
OK
RUN asdl/front_end_test.py > _test/py-unit/asdl/front_end_test.py.log
OK
RUN asdl/gen_python_test.py > _test/py-unit/asdl/gen_python_test.py.log
OK
RUN asdl/target_lang_test.py > _test/py-unit/asdl/target_lang_test.py.log
OK
RUN benchmarks/uftrace_allocs_test.py > _test/py-unit/benchmarks/uftrace_allocs_test.py.log
OK
RUN build/dynamic_deps_test.py > _test/py-unit/build/dynamic_deps_test.py.log
OK
RUN build/ninja_lib_test.py > _test/py-unit/build/ninja_lib_test.py.log
OK
RUN builtin/bracket_osh_test.py > _test/py-unit/builtin/bracket_osh_test.py.log
OK
RUN builtin/completion_osh_test.py > _test/py-unit/builtin/completion_osh_test.py.log
OK
RUN builtin/func_misc_test.py > _test/py-unit/builtin/func_misc_test.py.log
OK
RUN builtin/misc_osh_test.py > _test/py-unit/builtin/misc_osh_test.py.log
OK
RUN builtin/read_osh_test.py > _test/py-unit/builtin/read_osh_test.py.log
OK
RUN builtin/readline_osh_test.py > _test/py-unit/builtin/readline_osh_test.py.log
OK
RUN builtin/trap_osh_test.py > _test/py-unit/builtin/trap_osh_test.py.log
OK
RUN client/py_fanos_test.py > _test/py-unit/client/py_fanos_test.py.log
OK
RUN core/alloc_test.py > _test/py-unit/core/alloc_test.py.log
OK
RUN core/comp_ui_test.py > _test/py-unit/core/comp_ui_test.py.log
OK
RUN core/completion_test.py > _test/py-unit/core/completion_test.py.log
OK
RUN core/process_test.py > _test/py-unit/core/process_test.py.log
OK
RUN core/pyutil_test.py > _test/py-unit/core/pyutil_test.py.log
OK
RUN core/state_test.py > _test/py-unit/core/state_test.py.log
OK
RUN core/util_test.py > _test/py-unit/core/util_test.py.log
OK
RUN data_lang/htm8_test.py > _test/py-unit/data_lang/htm8_test.py.log
OK
RUN data_lang/htm8_util_test.py > _test/py-unit/data_lang/htm8_util_test.py.log
OK
RUN data_lang/j8_test.py > _test/py-unit/data_lang/j8_test.py.log
OK
RUN data_lang/pyj8_test.py > _test/py-unit/data_lang/pyj8_test.py.log
OK
RUN devtools/services/zulip_test.py > _test/py-unit/devtools/services/zulip_test.py.log
OK
RUN display/pretty_test.py > _test/py-unit/display/pretty_test.py.log
OK
RUN display/ui_test.py > _test/py-unit/display/ui_test.py.log
OK
RUN doctools/cmark_test.py > _test/py-unit/doctools/cmark_test.py.log
OK
RUN doctools/help_gen_test.py > _test/py-unit/doctools/help_gen_test.py.log
OK
RUN doctools/html_lib_test.py > _test/py-unit/doctools/html_lib_test.py.log
OK
RUN doctools/html_old_test.py > _test/py-unit/doctools/html_old_test.py.log
OK
RUN doctools/oils_doc_test.py > _test/py-unit/doctools/oils_doc_test.py.log
OK
RUN doctools/spelling_test.py > _test/py-unit/doctools/spelling_test.py.log
OK
RUN doctools/split_doc_test.py > _test/py-unit/doctools/split_doc_test.py.log
OK
RUN doctools/ul_table_test.py > _test/py-unit/doctools/ul_table_test.py.log
OK
RUN frontend/args_test.py > _test/py-unit/frontend/args_test.py.log
OK
RUN frontend/id_kind_def_test.py > _test/py-unit/frontend/id_kind_def_test.py.log
OK
RUN frontend/lexer_def_test.py > _test/py-unit/frontend/lexer_def_test.py.log
OK
RUN frontend/lexer_gen_test.py > _test/py-unit/frontend/lexer_gen_test.py.log
OK
RUN frontend/lexer_test.py > _test/py-unit/frontend/lexer_test.py.log
OK
RUN frontend/match_test.py > _test/py-unit/frontend/match_test.py.log
OK
RUN frontend/reader_test.py > _test/py-unit/frontend/reader_test.py.log
OK
RUN frontend/typed_args_test.py > _test/py-unit/frontend/typed_args_test.py.log
OK
RUN mycpp/format_strings_test.py > _test/py-unit/mycpp/format_strings_test.py.log
OK
RUN mycpp/mops_test.py > _test/py-unit/mycpp/mops_test.py.log
OK
RUN mycpp/mylib_test.py > _test/py-unit/mycpp/mylib_test.py.log
OK
RUN mycpp/pass_state_test.py > _test/py-unit/mycpp/pass_state_test.py.log
OK
RUN osh/arith_parse_test.py > _test/py-unit/osh/arith_parse_test.py.log
OK
RUN osh/bool_parse_test.py > _test/py-unit/osh/bool_parse_test.py.log
OK
RUN osh/braces_test.py > _test/py-unit/osh/braces_test.py.log
OK
RUN osh/cmd_eval_test.py > _test/py-unit/osh/cmd_eval_test.py.log
OK
RUN osh/cmd_parse_test.py > _test/py-unit/osh/cmd_parse_test.py.log

=== /home/uke/oil/_test/py-unit/osh/cmd_parse_test.py.log ===

  array=(a b c) ls
  ^~~~~~
"<cmd_parse_test>":1: Environment bindings can't contain array literals
..(command.CommandList
  children:[
    (command.ShAssignment
      left:<Lit_VarLike "empty=">
      pairs:[
        (AssignPair
          left:...0x7f798d69e7c0
          lhs:(sh_lhs.Name left:...0x7f798d69e7c0 name:empty)
          op:assign_op.Equal
          rhs:(w
            (word_part.InitializerLiteral
              left:<Op_LParen "(">
              pairs:[]
              right:<Right_Initializer ")">
            )
          )
        )
      ]
    )
  ]
)
(command.CommandList
  children:[
    (command.ShAssignment
      left:<Lit_VarLike "array=">
      pairs:[
        (AssignPair
          left:...0x7f798d69e280
          lhs:(sh_lhs.Name left:...0x7f798d69e280 name:array)
          op:assign_op.Equal
          rhs:(w
            (word_part.InitializerLiteral
              left:<Op_LParen "(">
              pairs:[
                (InitializerWord.ArrayWord w:(w <Lit_Chars a>))
                (InitializerWord.ArrayWord w:(w <Lit_Chars b>))
                (InitializerWord.ArrayWord w:(w <Lit_Chars c>))
              ]
              right:<Right_Initializer ")">
            )
          )
        )
      ]
    )
  ]
)
(command.CommandList
  children:[
    (command.Sentence
      child:(command.ShAssignment
        left:<Lit_VarLike "array=">
        pairs:[
          (AssignPair
            left:...0x7f798d69ead0
            lhs:(sh_lhs.Name left:...0x7f798d69ead0 name:array)
            op:assign_op.Equal
            rhs:(w
              (word_part.InitializerLiteral
                left:<Op_LParen "(">
                pairs:[
                  (InitializerWord.ArrayWord w:(w <Lit_Chars a>))
                  (InitializerWord.ArrayWord w:(w <Lit_Chars b>))
                  (InitializerWord.ArrayWord w:(w <Lit_Chars c>))
                ]
                right:<Right_Initializer ")">
              )
            )
          )
        ]
      )
      terminator:<Op_Semi ";">
    )
    (command.ShAssignment
      left:<Lit_VarLike "array2=">
      pairs:[
        (AssignPair
          left:...0x7f798d5eb1a0
          lhs:(sh_lhs.Name left:...0x7f798d5eb1a0 name:array2)
          op:assign_op.Equal
          rhs:(w
            (word_part.InitializerLiteral
              left:<Op_LParen "(">
              pairs:[
                (InitializerWord.ArrayWord w:(w <Lit_Chars d>))
                (InitializerWord.ArrayWord w:(w <Lit_Chars e>))
                (InitializerWord.ArrayWord w:(w <Lit_Chars f>))
              ]
              right:<Right_Initializer ")">
            )
          )
        )
      ]
    )
  ]
)
(C (w <Lit_Chars ls>) (w <Lit_Chars foo>))
(command.Pipeline
  children:[
    (C (w <Lit_Chars ls>) (w <Lit_Chars foo>))
    (C (w <Lit_Chars wc>) (w <Lit_Chars -l>))
  ]
  ops:[<Op_Pipe "|">]
)
(command.AndOr
  children:[(C (w <Lit_Chars ls>) (w <Lit_Chars foo>)) (C (w <Lit_Chars die>))]
  ops:[<Op_DPipe "||">]
)
(command.AndOr
  children:[
    (command.Pipeline
      children:[
        (C (w <Lit_Chars ls>) (w <Lit_Chars foo>))
        (C (w <Lit_Chars wc>) (w <Lit_Chars -l>))
      ]
      ops:[<Op_Pipe "|">]
    )
    (C (w <Lit_Chars die>))
  ]
  ops:[<Op_DPipe "||">]
)
(command.Case
  case_kw:<KW_Case case>
  to_match:(case_arg.Word w:(w <Lit_Chars foo>))
  arms_start:<KW_In in>
  arms:[]
  arms_end:<KW_Esac esac>
)
(command.Case
  case_kw:<KW_Case case>
  to_match:(case_arg.Word w:(w <Lit_Chars word>))
  arms_start:<KW_In in>
  arms:[
    (CaseArm
      left:<Lit_Chars foo>
      pattern:(pat.Words
        words:[(w <Lit_Chars foo>) (w <Lit_Chars foo2>) (w <Lit_Chars foo3>)]
      )
      middle:<Right_CasePat ")">
      action:[(C (w <Lit_Chars echo>) (w <Lit_Chars hi>))]
      right:<Op_DSemi ";;">
    )
  ]
  arms_end:<KW_Esac esac>
)
(command.Case
  case_kw:<KW_Case case>
  to_match:(case_arg.Word w:(w <Lit_Chars word>))
  arms_start:<KW_In in>
  arms:[
    (CaseArm
      left:<Lit_Chars foo>
      pattern:(pat.Words words:[(w <Lit_Chars foo>)])
      middle:<Right_CasePat ")">
      action:[(C (w <Lit_Chars echo>) (w <Lit_Chars one-line>))]
      right:<Op_DSemi ";;">
    )
  ]
  arms_end:<KW_...Esac esac>
)
(command.Case
  case_kw:<KW_Case case>
  to_match:(case_arg.Word w:(w <Lit_Chars word>))
  arms_start:<KW_In in>
  arms:[
    (CaseArm
      left:<Lit_Chars foo>
      pattern:(pat.Words words:[(w <Lit_Chars foo>)])
      middle:<Right_CasePat ")">
      action:[(C (w <Lit_Chars echo>) (w <Lit_Chars foo>))]
      right:<Op_DSemi ";;">
    )
    (CaseArm
      left:<Lit_Chars bar>
      pattern:(pat.Words words:[(w <Lit_Chars bar>)])
      middle:<Right_CasePat ")">
      action:[(C (w <Lit_Chars echo>) (w <Lit_Chars bar>))]
      right:<Op_DSemi ";;">
    )
  ]
  arms_end:<KW_Esac esac>
)
(command.Case
  case_kw:<KW_Case case>
  to_match:(case_arg.Word w:(w <Lit_Chars word>))
  arms_start:<KW_In in>
  arms:[
    (CaseArm
      left:<Lit_Chars foo>
      pattern:(pat.Words words:[(w <Lit_Chars foo>)])
      middle:<Right_CasePat ")">
      action:[(C (w <Lit_Chars echo>) (w <Lit_Chars foo>))]
      right:<Op_DSemi ";;">
    )
    (CaseArm
      left:<Lit_Chars bar>
      pattern:(pat.Words words:[(w <Lit_Chars bar>)])
      middle:<Right_CasePat ")">
      action:[
        (command.Sentence
          child:(C (w <Lit_Chars echo>) (w <Lit_Chars bar>))
          terminator:<Op_Semi ";">
        )
      ]
    )
  ]
  arms_end:<KW_Esac esac>
)
(command.Case
  case_kw:<KW_Case case>
  to_match:(case_arg.Word w:(w <Lit_Chars word>))
  arms_start:<KW_In in>
  arms:[
    (CaseArm
      left:<Lit_Chars foo>
      pattern:(pat.Words words:[(w <Lit_Chars foo>)])
      middle:<Right_CasePat ")">
      action:[(C (w <Lit_Chars echo>) (w <Lit_Chars foo>))]
      right:<Op_DSemi ";;">
    )
    (CaseArm
      left:<Lit_Chars bar>
      pattern:(pat.Words words:[(w <Lit_Chars bar>)])
      middle:<Right_CasePat ")">
      action:[(C (w <Lit_Chars echo>) (w <Lit_Chars bar>))]
    )
  ]
  arms_end:<KW_Esac esac>
)
(command.Simple
  blame_tok:(Token
    id:Lit_Chars
    length:2
    col:0
    line:(SourceLine
      line_num:1
      content:"ls foo"
      src:(source.MainFile path:"<test_lib>")
    )
  )
  more_env:[]
  words:[
    (CompoundWord parts:[...0x7f798d551c20])
    (CompoundWord
      parts:[(Token id:Lit_Chars length:3 col:3 line:...0x7f798d69df50)]
    )
  ]
  is_last_cmd:F
)

(ShFunction
  name_tok:(Token
    id:Lit_Chars
    length:3
    col:0
    line:(SourceLine
      line_num:1
      content:"fun() { echo hi; }"
      src:(source.MainFile path:"<test_lib>")
    )
  )
  name:fun
  body:(BraceGroup
    left:(Token id:Lit_LBrace length:1 col:6 line:...0x7f798d69d7d0)
    children:[
      (command.Sentence
        child:(command.Simple
          blame_tok:(Token id:Lit_Chars length:4 col:8 line:...0x7f798d69d7d0)
          more_env:[]
          words:[
            (CompoundWord parts:[...0x7f798d624440])
            (CompoundWord
              parts:[
                (Token id:Lit_Chars length:2 col:13 line:...0x7f798d69d7d0)
              ]
            )
          ]
          is_last_cmd:F
        )
        terminator:(Token id:Op_Semi length:1 col:15 line:...0x7f798d69d7d0)
      )
    ]
    right:(Token id:Lit_RBrace length:1 col:17 line:...0x7f798d69d7d0)
  )
  code_str:"fun() { echo hi; }"
)

(C
  (w <Lit_Chars echo>)
  (w
    (CommandSub
      left_token:<Left_DollarParen "$(">
      child:(C (w <Lit_Chars echo>) (w <Lit_Number 12>))
      right:<Eof_RParen ")">
    )
    (CommandSub
      left_token:<Left_DollarParen "$(">
      child:(C (w <Lit_Chars echo>) (w <Lit_Number 34>))
      right:<Eof_RParen ")">
    )
  )
)
(C
  (w <Lit_Chars echo>)
  (w
    (DQ
      (CommandSub
        left_token:<Left_DollarParen "$(">
        child:(C (w <Lit_Chars echo>) (w <Lit_Number 12>))
        right:<Eof_RParen ")">
      )
      (CommandSub
        left_token:<Left_DollarParen "$(">
        child:(C (w <Lit_Chars echo>) (w <Lit_Number 34>))
        right:<Eof_RParen ")">
      )
    )
  )
)
(command.CommandList
  children:[
    (command.DBracket
      left:<KW_DLeftBracket "[[">
      expr:(bool_expr.Binary
        op_id:BoolBinary_gt
        left:(w ($ VSub_Pound))
        right:(w <Lit_Chars 1>)
      )
      right:....<Lit_DRightBracket "]]">
    )
  ]
)
(command.CommandList
  children:[
    (command.DBracket
      left:<KW_DLeftBracket "[[">
      expr:(bool_expr.LogicalAnd
        left:(bool_expr.Binary
          op_id:BoolBinary_gt
          left:(w ($ VSub_Pound))
          right:(w <Lit_Chars 1>)
        )
        right:(bool_expr.WordTest w:(w <Lit_Chars foo>))
      )
      right:<Lit_DRightBracket "]]">
    )
  ]
)
(command.CommandList
  children:[
    (command.If
      if_kw:<KW_If if>
      arms:[
        (IfArm
          keyword:...0x7f798d5eb3d0
          cond:(List_of_command
            (command.DBracket
              left:<KW_DLeftBracket "[[">
              expr:(bool_expr.Binary
                op_id:BoolBinary_gt
                left:(w ($ VSub_Pound))
                right:(w <Lit_Chars 1>)
              )
              right:<Lit_DRightBracket "]]">
            )
          )
          then_kw:<KW_Then then>
          action:[(C (w <Lit_Chars echo>) (w <Lit_Chars hi>))]
          then_tok:...0x7f798d5ebec0
        )
      ]
      else_action:[]
      fi_kw:<KW_Fi fi>
    )
  ]
)
(command.CommandList
  children:[
    (command.DBracket
      left:<KW_DLeftBracket "[[">
      expr:(bool_expr.Binary
        op_id:BoolBinary_EqualTilde
        left:(w <Lit_Chars foo>)
        right:(w <Lit_Chars foo>)
      )
      right:<Lit_DRightBracket "]]">
    )
  ]
)
(command.CommandList
  children:[
    (command.DBracket
      left:<KW_DLeftBracket "[[">
      expr:(bool_expr.Binary
        op_id:BoolBinary_EqualTilde
        left:(w <Lit_Chars foo>)
        right:(w
          (word_part.BashRegexGroup
            left:<BashRegex_LParen "(">
            child:(w <Lit_Chars foo> <Lit_Other "|"> <Lit_Chars bar>)
            right:<Right_BashRegexGroup ")">
          )
        )
      )
      right:<Lit_DRightBracket "]]">
    )
  ]
)
(command.CommandList
  children:[
    (command.DParen
      left:<Op_DLeftParen "((">
      child:(arith_expr.Binary
        op:<Arith_Plus "+">
        left:(w <Lit_Digits 1>)
        right:(w <Lit_Digits 2>)
      )
      right:<Op_DRightParen ")">
    )
  ]
)
(command.CommandList
  children:[
    (command.ForEach
      keyword:<KW_For for>
      iter_names:[i]
      iterable:(for_iter.Words
        words:[(w <Lit_Number 1>) (w <Lit_Number 2>) (w <Lit_Number 3>)]
      )
      semi_tok:<Op_Semi ";">
      body:(command.DoGroup
        left:<KW_Do do>
        children:[(C (w <Lit_Chars echo>) (w ($ i)))]
        right:<KW_Done done>
      )
    )
  ]
)
(command.CommandList
  children:[
    (command.ForEach
      keyword:<KW_For for>
      iter_names:[i]
      iterable:(for_iter.Words words:[])
      semi_tok:<Op_Semi ";">
      body:(command.DoGroup
        left:<KW_Do do>
        children:[(C (w <Lit_Chars echo>) (w ($ i)))]
        right:<KW_Done done>
      )
    )
  ]
)
(command.CommandList
  children:[
    (command.ForEach
      keyword:<KW_For for>
      iter_names:[i]
      iterable:(for_iter.Args)
      body:(command.DoGroup
        left:<KW_Do do>
        children:[
          (command.Sentence
            child:(C (w <Lit_Chars echo>) (w ($ i)))
            terminator:<Op_Semi ";">
          )
        ]
        right:<KW_Done done>
      )
    )
  ]
)
(command.CommandList
  children:[
    (command.ForEach
      keyword:<KW_For for>
      iter_names:[i]
      iterable:(for_iter.Args)
      body:(command.DoGroup
        left:<KW_Do do>
        children:[(C (w <Lit_Chars echo>) (w ($ i)))]
        right:<KW_Done done>
      )
    )
  ]
)
(command.CommandList
  children:[
    (command.ForExpr
      keyword:<KW_For for>
      init:(arith_expr.BinaryAssign
        op_id:Arith_Equal
        left:<Lit_ArithVarLike i>
        right:(w <Lit_Digits 0>)
      )
      cond:(arith_expr.Binary
        op:<Arith_Less "<">
        left:<Lit_ArithVarLike i>
        right:(w <Lit_Digits 5>)
      )
      update:(arith_expr.UnaryAssign
        op_id:Arith_DPlus
        child:<Lit_ArithVarLike i>
      )
      body:(command.DoGroup
        left:<KW_Do do>
        children:[(C (w <Lit_Chars echo>) (w ($ i)))]
    .    right:<KW_Done done>
      )
    )
  ]
)
(command.CommandList
  children:[
    (command.ForExpr
      keyword:<KW_For for>
      init:(arith_expr.BinaryAssign
        op_id:Arith_Equal
        left:<Lit_ArithVarLike i>
        right:(w <Lit_Digits 0>)
      )
      cond:(arith_expr.Binary
        op:<Arith_Less "<">
        left:<Lit_ArithVarLike i>
        right:(w <Lit_Digits 5>)
      )
      update:(arith_expr.UnaryAssign
        op_id:Arith_DPlus
        child:<Lit_ArithVarLike i>
      )
      body:(command.DoGroup
        left:<KW_Do do>
        children:[(C (w <Lit_Chars echo>) (w ($ i)))]
        right:<KW_Done done>
      )
    )
  ]
)
(command.CommandList
  children:[
    (command.ForExpr
      keyword:<KW_For for>
      init:(arith_expr.EmptyZero)
      cond:(arith_expr.EmptyOne)
      update:...0x7f798db717d0
      body:(command.DoGroup
        left:<KW_Do do>
        children:[(C (w <Lit_Chars echo>) (w ($ i)))]
        right:<KW_Done done>
      )
    )
  ]
)
(command.CommandList
  children:[
    (ShFunction
      name_tok:<Lit_Chars foo>
      name:foo
      body:(BraceGroup
        left:<Lit_LBrace "{">
        children:[
          (command.Sentence
            child:(C (w <Lit_Chars echo>) (w <Lit_Chars hi>))
            terminator:<Op_Semi ";">
          )
        ]
        right:<Lit_RBrace "}">
      )
      code_str:"foo() { echo hi; }"
    )
  ]
)
(command.CommandList
  children:[
    (ShFunction
      name_tok:<Lit_Chars foo>
      name:foo
      body:(command.Subshell
        left:<Op_LParen "(">
        child:(C (w <Lit_Chars echo>) (w <Lit_Chars hi>))
        right:<Right_Subshell ")">
        is_last_cmd:F
      )
      code_str:"foo() ( echo hi )"
    )
  ]
)
(command.CommandList
  children:[
    (ShFunction
      name_tok:<Lit_Chars foo>
      name:foo
      body:(command.ForEach
        keyword:<KW_For for>
        iter_names:[i]
        iterable:(for_iter.Words words:[(w <Lit_Chars x>)])
        semi_tok:<Op_Semi ";">
        body:(command.DoGroup
          left:<KW_Do do>
          children:[
            (command.Sentence
              child:(C (w <Lit_Chars echo>) (w ($ i)))
              terminator:<Op_Semi ";">
            )
          ]
          right:<KW_Done done>
        )
      )
    )
  ]
)
(command.CommandList
  children:[
    (ShFunction
      keyword:<KW_Function function>
      name_tok:<Lit_Chars foo>
      name:foo
      body:(BraceGroup
        left:<Lit_LBrace "{">
        children:[
          (command.Sentence
            child:(C (w <Lit_Chars echo>) (w <Lit_Chars hi>))
            terminator:<Op_Semi ";">
          )
        ]
        right:<Lit_RBrace "}">
      )
      code_str:"function foo { echo hi; }"
    )
  ]
)
(command.CommandList
  children:[
    (ShFunction
      keyword:<KW_Function function>
      name_tok:<Lit_Chars foo>
      name:foo
      body:(BraceGroup
        left:<Lit_LBrace "{">
        children:[
          (command.Sentence
            child:(C (w <Lit_Chars echo>) (w <Lit_Chars hi>))
            terminator:<Op_Semi ";">
          )
        ]
        right:<Lit_RBrace "}">
      )
      code_str:"function foo () { echo hi; }"
    )
  ]
)
(command.CommandList
  children:[
    (ShFunction
      keyword:<KW_Function function>
      name_tok:<Lit_Chars foo>
      name:foo
      body:(command.Subshell
        left:<Op_LParen "(">
        child:(C (w <Lit_Chars echo>) (w <Lit_Chars hi>))
        right:<Right_Subshell ")">
        is_last_cmd:F
      )
      code_str:"function foo() ( echo hi )"
    )
  ]
)
(command.CommandList
  children:[
    (ShFunction
      keyword:<KW_Function function>
      name_tok:<Lit_Chars foo>
      name:foo
      body:(command.ForEach
        keyword:<KW_For for>
        iter_names:[i]
        iterable:(for_iter.Words words:[(w <Lit_Chars x>)])
        semi_tok:<Op_Semi ";">
        body:(command.DoGroup
          left:<KW_Do do>
          children:[
            (command.Sentence
              child:(C (w <Lit_Chars echo>) (w ($ i)))
              terminator:<Op_Semi ";">
            )
          ]
          right:<KW_...  ls foo|
         ^
"<cmd_parse_test>":1: Unexpected EOF while parsing command
.Done done>
        )
      )
    )
  ]
)
(command.CommandList
  children:[
    (ShFunction
      keyword:<KW_Function function>
      name_tok:<Lit_Chars foo>
      name:foo
      body:(command.ForEach
        keyword:<KW_For for>
        iter_names:[i]
        iterable:(for_iter.Words words:[(w <Lit_Chars x>)])
        semi_tok:<Op_Semi ";">
        body:(command.DoGroup
          left:<KW_Do do>
          children:[
            (command.Sentence
              child:(C (w <Lit_Chars echo>) (w ($ i)))
              terminator:<Op_Semi ";">
            )
          ]
          right:<KW_Done done>
        )
      )
    )
  ]
)
(command.CommandList
  children:[
    (ShFunction
      name_tok:<Lit_Chars foo>
      name:foo
      body:(command.Redirect
        child:(BraceGroup
          left:<Lit_LBrace "{">
          children:[
            (command.Sentence
              child:(C (w <Lit_Chars echo>) (w <Lit_Chars hi>))
              terminator:<Op_Semi ";">
            )
          ]
          right:<Lit_RBrace "}">
        )
        redirects:[
          (Redir
            op:<Redir_GreatAnd ">&">
            loc:(redir_loc.Fd fd:1)
            arg:(w <Lit_Number 2>)
          )
          (Redir
            op:<Redir_Great ">">
            loc:(redir_loc.Fd fd:2)
            arg:(w
              <Lit_Slash />
              <Lit_Chars dev>
              <Lit_Slash />
              <Lit_Chars "null">
            )
          )
        ]
      )
    )
  ]
)
(command.CommandList
  children:[
    (command.If
      if_kw:<KW_If if>
      arms:[
        (IfArm
          keyword:...0x7f798d551590
          cond:(List_of_command
            (command.Sentence
              child:(C (w <Lit_Chars "true">))
              terminator:<Op_Semi ";">
            )
          )
          then_kw:<KW_Then then>
          action:[
            (command.Sentence
              child:(C (w <Lit_Chars echo>) (w <Lit_Chars yes>))
              terminator:<Op_Semi ";">
            )
          ]
          then_tok:...0x7f798d49d600
        )
      ]
      else_action:[]
      fi_kw:<KW_Fi fi>
    )
  ]
)
(command.CommandList
  children:[
    (command.If
      if_kw:<KW_If if>
      arms:[
        (IfArm
          keyword:...0x7f798d551050
          cond:(List_of_command
            (command.Sentence
              child:(command.Subshell
                left:<Op_LParen "(">
                child:(C (w <Lit_Chars "true">))
                right:<Right_Subshell ")">
                is_last_cmd:F
              )
              terminator:<Op_Semi ";">
            )
          )
          then_kw:<KW_Then then>
          action:[
            (command.Sentence
              child:(C (w <Lit_Chars echo>) (w <Lit_Chars yes>))
              terminator:<Op_Semi ";">
            )
          ]
          then_tok:...0x7f798d551280
        )
      ]
      else_action:[]
      fi_kw:<KW_Fi fi>
    )
  ]
)
(command.CommandList children:[(C (w <Lit_Chars ifFOO>))])
(C (w <Lit_Chars ls>) (w <Lit_Chars foo>))
(command.Pipeline
  children:[
    (C (w <Lit_Chars ls>) (w <Lit_Chars foo>))
    (C (w <Lit_Chars wc>) (w <Lit_Chars -l>))
  ]
  ops:[<Op_Pipe "|">]
)
(command.Pipeline
  negated:<KW_Bang "!">
  children:[
    (C (w <Lit_Chars echo>) (w <Lit_Chars foo>))
    (C (w <Lit_Chars grep>) (w <Lit_Chars foo>))
  ]
  ops:[<Op_Pipe "|">]
)
(command.Pipeline
  children:[
    (C (w <Lit_Chars ls>) (w <Lit_Chars foo>))
    (C (w <Lit_Chars wc>) (w <Lit_Chars -l>))
    (C (w <Lit_Chars less>))
  ]
  ops:[<Op_Pipe "|"> <Op_Pipe "|">]
)
(command.CommandList
  children:[
    (command.Pipeline
      children:[
        (C (w <Lit_Chars ls>))
        (C (w <Lit_Chars cat>))
        (C (w <Lit_Chars cat>))
      ]
      ops:[<Op_Pipe "|"> <Op_PipeAmp "|&">]
    )
  ]
)
(command.CommandList
  children:[
    (command.Pipeline
      children:[
        (C (w <Lit_Chars ls>))
        (C (w <Lit_Chars cat>))
        (C (w <Lit_Chars cat>))
      ]
      ops:[<Op_PipeAmp "|&"> <Op_Pipe "|">]
    )
  ]
)
(command.CommandList
  children:[
    (command.Pipeline
      children:[
        (C (w <Lit_....Chars ls>))
        (C (w <Lit_Chars cat>))
        (C (w <Lit_Chars cat>))
      ]
      ops:[<Op_PipeAmp "|&"> <Op_PipeAmp "|&">]
    )
  ]
)
(command.CommandList
  children:[
    (C
      (w <Lit_Chars ls>)
      (w (word_part.TildeSub left:<Lit_Tilde "~">))
      (w
        (word_part.TildeSub
          left:<Lit_Tilde "~">
          name:<Lit_Chars root>
          user_name:root
        )
      )
      (w
        (word_part.TildeSub left:<Lit_Tilde "~">)
        <Lit_Slash />
        <Lit_Chars src>
      )
      (w
        (word_part.TildeSub left:<Lit_Tilde "~">)
        <Lit_Slash />
        <Lit_Chars src>
        <Lit_Slash />
        <Lit_Chars foo>
      )
      (w
        (word_part.TildeSub
          left:<Lit_Tilde "~">
          name:<Lit_Chars root>
          user_name:root
        )
        <Lit_Slash />
        <Lit_Chars src>
      )
      (w
        <Lit_Tilde "~">
        <Lit_Chars weird>
        <KW_Bang "!">
        <Lit_Chars name>
        <Lit_Slash />
        <Lit_Chars blah>
        <KW_Bang "!">
        <Lit_Chars blah>
      )
    )
  ]
)
(command.CommandList
  children:[
    (command.WhileUntil
      keyword:<KW_Until until>
      cond:(List_of_command
        (command.Sentence
          child:(C (w <Lit_Chars "false">))
          terminator:<Op_Semi ";">
        )
      )
      body:(command.DoGroup
        left:<KW_Do do>
        children:[
          (C (w <Lit_Chars echo>) (w <Lit_Chars hi>))
          (command.ControlFlow keyword:<ControlFlow_Break break>)
        ]
        right:<KW_Done done>
      )
    )
  ]
)
(command.CommandList
  children:[
    (command.WhileUntil
      keyword:<KW_While while>
      cond:(List_of_command
        (command.Sentence
          child:(C (w <Lit_Chars "true">))
          terminator:<Op_Semi ";">
        )
      )
      body:(command.DoGroup
        left:<KW_Do do>
        children:[
          (C (w <Lit_Chars echo>) (w <Lit_Chars hi>))
          (command.ControlFlow keyword:<ControlFlow_Break break>)
        ]
        right:<KW_Done done>
      )
    )
  ]
)
(command.CommandList
  children:[
    (command.WhileUntil
      keyword:<KW_While while>
      cond:(List_of_command (C (w <Lit_Chars "true">)))
      body:(command.DoGroup
        left:<KW_Do do>
        children:[
          (C (w <Lit_Chars echo>) (w <Lit_Chars hi>))
          (command.ControlFlow keyword:<ControlFlow_Break break>)
        ]
        right:<KW_Done done>
      )
    )
  ]
)
(command.Case
  case_kw:<KW_Case case>
  to_match:(case_arg.YshExpr e:(Var x))
  arms_start:<Lit_LBrace "{">
  arms:[]
  arms_end:<Lit_RBrace "}">
)
(command.Case
  case_kw:<KW_Case case>
  to_match:(case_arg.YshExpr e:(Var x))
  arms_start:<Lit_LBrace "{">
  arms:[
    (CaseArm
      left:<Op_LParen "(">
      pattern:(pat.Else)
      middle:<Lit_LBrace "{">
      action:[
        (command.Sentence
          child:(C (w <Lit_Chars echo>) (w <Lit_Chars hi>))
          terminator:<Op_Semi ";">
        )
      ]
      right:<Lit_RBrace "}">
    )
  ]
  arms_end:<Lit_RBrace "}">
)
(command.Case
  case_kw:<KW_Case case>
  to_match:(case_arg.YshExpr e:(Var x))
  arms_start:<Lit_LBrace "{">
  arms:[
    (CaseArm
      left:<Op_LParen "(">
      pattern:(pat.YshExprs exprs:[(Const Expr_DecInt _) (Const Expr_DecInt _)])
      middle:<Lit_LBrace "{">
      action:[
        (command.Sentence
          child:(C (w <Lit_Chars echo>) (w <Lit_Chars hi>))
          terminator:<Op_Semi ";">
        )
      ]
      right:<Lit_RBrace "}">
    )
  ]
  arms_end:<Lit_RBrace "}">
)
(command.Case
  case_kw:<KW_Case case>
  to_match:(case_arg.YshExpr e:(Var x))
  arms_start:<Lit_LBrace "{">
  arms:[
    (CaseArm
      left:<Lit_Chars bare>
      pattern:(pat.Words
        words:[(w <Lit_Chars bare>) (w <Lit_Chars x>) (w (SQ string))]
      )
      middle:<Lit_LBrace "{">
      action:[
        (command.Sentence
          child:(C (w <Lit_Chars echo>) (w <Lit_Chars hi>))
          terminator:<Op_Semi ";">
        )
      ]
      right:<Lit_RBrace "}">
    )
  ]
  arms_end:<Lit_RBrace "}">
)
(command.Case
  case_kw:<KW_Case case>
  to.._match:(case_arg.YshExpr e:(Var x))
  arms_start:<Lit_LBrace "{">
  arms:[
    (CaseArm
      left:<Arith_Slash />
      pattern:(Eggex
        left:...0x7f798d51f520
        regex:(re.Repeat child:(PerlClass name:d) op:<Arith_Plus "+">)
        flags:[]
        canonical_flags:""
      )
      middle:<Lit_LBrace "{">
      action:[
        (command.Sentence
          child:(C (w <Lit_Chars echo>) (w <Lit_Chars space>))
          terminator:<Op_Semi ";">
        )
      ]
      right:<Lit_RBrace "}">
    )
    (CaseArm
      left:<Arith_Slash />
      pattern:(Eggex
        left:...0x7f798d5516e0
        regex:(re.Repeat child:(PerlClass name:d) op:<Arith_Plus "+">)
        flags:[]
        canonical_flags:""
      )
      middle:<Lit_LBrace "{">
      action:[
        (command.Sentence
          child:(C (w <Lit_Chars echo>) (w <Lit_Chars space2>))
          terminator:<Op_Semi ";">
        )
      ]
      right:<Lit_RBrace "}">
    )
  ]
  arms_end:<Lit_RBrace "}">
)
(command.Case
  case_kw:<KW_Case case>
  to_match:(case_arg.YshExpr e:(Var x))
  arms_start:<Lit_LBrace "{">
  arms:[
    (CaseArm
      left:<Lit_Chars word>
      pattern:(pat.Words words:[(w <Lit_Chars word>)])
      middle:<Lit_LBrace "{">
      action:[(ExprCommand keyword:<Lit_Equals "="> e:(Var x))]
      right:<Lit_RBrace "}">
    )
  ]
  arms_end:<Lit_RBrace "}">
)
(command.Case
  case_kw:<KW_Case case>
  to_match:(case_arg.YshExpr e:(Var x))
  arms_start:<Lit_LBrace "{">
  arms:[
    (CaseArm
      left:<Arith_Slash />
      pattern:(Eggex
        left:...0x7f798d574bb0
        regex:(SQ eggex)
        flags:[]
        canonical_flags:""
      )
      middle:<Lit_LBrace "{">
      action:[(ExprCommand keyword:<Lit_Equals "="> e:(Var x))]
      right:<Lit_RBrace "}">
    )
  ]
  arms_end:<Lit_RBrace "}">
)
(command.Case
  case_kw:<KW_Case case>
  to_match:(case_arg.YshExpr e:(Var x))
  arms_start:<Lit_LBrace "{">
  arms:[
    (CaseArm
      left:<Op_LParen "(">
      pattern:(pat.YshExprs exprs:[(SQ expr)])
      middle:<Lit_LBrace "{">
      action:[(ExprCommand keyword:<Lit_Equals "="> e:(Var x))]
      right:<Lit_RBrace "}">
    )
  ]
  arms_end:<Lit_RBrace "}">
)
(command.Case
  case_kw:<KW_Case case>
  to_match:(case_arg.YshExpr e:(Var x))
  arms_start:<Lit_LBrace "{">
  arms:[
    (CaseArm
      left:<Op_LParen "(">
      pattern:(pat.Else)
      middle:<Lit_LBrace "{">
      action:[(ExprCommand keyword:<Lit_Equals "="> e:(Var x))]
      right:<Lit_RBrace "}">
    )
  ]
  arms_end:<Lit_RBrace "}">
)
(C (w <Lit_Chars ls>) (w <Lit_Chars foo>))
(command.Pipeline
  children:[
    (C (w <Lit_Chars ls>) (w <Lit_Chars foo>))
    (C (w <Lit_Chars wc>) (w <Lit_Chars -l>))
  ]
  ops:[<Op_Pipe "|">]
)
(command.AndOr
  children:[
    (command.Pipeline
      children:[
        (C (w <Lit_Chars ls>) (w <Lit_Chars foo>))
        (C (w <Lit_Chars wc>) (w <Lit_Chars -l>))
      ]
      ops:[<Op_Pipe "|">]
    )
    (C (w <Lit_Chars die>))
  ]
  ops:[<Op_DPipe "||">]
)
(command.CommandList
  children:[
    (command.Sentence
      child:(command.AndOr
        children:[
          (command.Pipeline
            children:[
              (C (w <Lit_Chars ls>) (w <Lit_Chars foo>))
              (C (w <Lit_Chars wc>) (w <Lit_Chars -l>))
            ]
            ops:[<Op_Pipe "|">]
          )
          (C (w <Lit_Chars die>))
        ]
        ops:[<Op_DPipe "||">]
      )
      terminator:<Op_Semi ";">
    )
    (C (w <Lit_Chars ls>) (w <Lit_Slash />))
  ]
)
(command.CommandList children:[(C (w <Lit_Chars ls>) (w <Lit_Chars foo>))])
(command.CommandList
  children:[
    (command.Sentence
      child:(command.AndOr
        children:[
          (command.Pipeline
            children:[
              (C (w <Lit_Chars ls>) (w <Lit_Chars foo>))
              (C (w <Lit_Chars wc>) (w <Lit_Chars -l>))
            ]
            ops:[<Op_Pipe "|">]
          )
          (C (w <Lit_Chars die>))
        ]
        ops:[<Op_DPipe "||">]
      )
      terminator:<Op_Semi ";">
    )
    (C (w <Lit_Chars ls>) (w <Lit_Slash />))
  ]
)
(command.CommandList
  children:[
    (command.  (( 1 + ))
         ^
"<cmd_parse_test>":1: Token can't be used in prefix position
.  A= (1 2)
    ^
"<cmd_parse_test>":1: Expected ( after =
.  [[ foo bar ]]
         ^~~
"<cmd_parse_test>":1: Expected ]]
  [[ foo -eq ]]
               ^
"<cmd_parse_test>":1: Expected ]]
  [[ foo$(echo <) -eq foo ]]
                ^
"<cmd_parse_test>":1: Invalid token after redirect operator
.  ls <
      ^
"<cmd_parse_test>":1: Invalid token after redirect operator
  ls < <
       ^
"<cmd_parse_test>":1: Invalid token after redirect operator
  echo foo$(ls <)bar
                ^
"<cmd_parse_test>":1: Invalid token after redirect operator
  BAD_ENV=(1 2 3) ls
  ^~~~~~~~
"<cmd_parse_test>":1: Environment bindings can't contain array literals
  for ((i=1; i<)); do echo $i; done
               ^
"<cmd_parse_test>":1: Token can't be used in prefix position
  for ((i=1; i<5; ++i)) OOPS echo $i; ERR
                        ^~~~
"<cmd_parse_test>":1: Invalid word after for expression
  for ((i=1; i<5; ++i)); OOPS echo $i; ERR
                         ^~~~
"<cmd_parse_test>":1: Expected word type Id.KW_Do, got Id.Word_Compound
  for $bad in 1 2; do echo hi; done
      ^~~~
"<cmd_parse_test>":1: Expected loop variable (a constant word)
  for foo BAD
             ^
"<cmd_parse_test>":1: Expected loop variable (a constant word)
  if foo; then echo hi; z
                         ^
"<cmd_parse_test>":1: Expected word type Id.KW_Fi, got Id.Eof_Real
  foo$(invalid) () { echo hi; }
  ^~~
"<cmd_parse_test>":1: Invalid function name
.  foo="" echo "bar
              ^
"<cmd_parse_test>":1: Unexpected EOF reading double-quoted string that began here
..  for x in 1 2 $(
                 ^
"<cmd_parse_test>":1: Invalid word in for loop
.      for [ i = 1; i < 10; i++ ]
          ^
"<cmd_parse_test>":1: Invalid loop variable name '['
      for = in a
          ^
"<cmd_parse_test>":1: Invalid loop variable name '='
.  for x in 1 2 $(cat <<EOF
                     ^~
"<cmd_parse_test>":1: Couldn't find terminator for here doc that starts here
.      foo"bar" () {
      ^~~
"<cmd_parse_test>":1: Invalid function name
.........F..Sentence
      child:(command.AndOr
        children:[
          (command.Pipeline
            children:[
              (C (w <Lit_Chars ls>) (w <Lit_Chars foo>))
              (C (w <Lit_Chars wc>) (w <Lit_Chars -l>))
            ]
            ops:[<Op_Pipe "|">]
          )
          (C (w <Lit_Chars echo>) (w <Lit_Chars fail>))
        ]
        ops:[<Op_DPipe "||">]
      )
      terminator:<Op_Semi ";">
    )
    (command.AndOr
      children:[
        (command.Pipeline
          children:[
            (C (w <Lit_Chars echo>) (w <Lit_Chars bar>))
            (C (w <Lit_Chars wc>) (w <Lit_Chars -c>))
          ]
          ops:[<Op_Pipe "|">]
        )
        (C (w <Lit_Chars echo>) (w <Lit_Chars f2>))
      ]
      ops:[<Op_DPipe "||">]
    )
  ]
)
(C (w <Lit_Chars cat>))
(command.AndOr
  children:[(C (w <Lit_Chars cat>)) (C (w <Lit_Chars echo>) (w <Lit_Chars hi>))]
  ops:[<Op_DPipe "||">]
)
(command.AndOr
  children:[(C (w <Lit_Chars cat>)) (C (w <Lit_Chars echo>) (w <Lit_Chars hi>))]
  ops:[<Op_DAmp "&&">]
)
(command.AndOr
  children:[(C (w <Lit_Chars tac>)) (C (w <Lit_Chars tac>))]
  ops:[<Op_DAmp "&&">]
)
(command.Pipeline
  children:[(C (w <Lit_Chars cat>)) (C (w <Lit_Chars tac>))]
  ops:[<Op_Pipe "|">]
)
(command.Pipeline
  children:[(C (w <Lit_Chars cat>)) (C (w <Lit_Chars tac>))]
  ops:[<Op_Pipe "|">]
)
(command.CommandList
  children:[
    (command.Sentence child:(C (w <Lit_Chars cat>)) terminator:<Op_Semi ";">)
    (C (w <Lit_Chars echo>) (w <Lit_Chars hi>))
  ]
)
(command.CommandList
  children:[
    (command.Sentence child:(C (w <Lit_Chars cat>)) terminator:<Op_Semi ";">)
    (C (w <Lit_Chars echo>) (w <Lit_Chars hi>))
  ]
)
(C (w <Lit_Chars cat>))
(C (w <Lit_Chars cat>))
(C (w <Lit_Chars cat>))
(C (w <Lit_Chars cat>))
(command.CommandList
  children:[
    (command.Pipeline
      children:[(C (w <Lit_Chars cat>)) (C (w <Lit_Chars tac>))]
      ops:[<Op_Pipe "|">]
    )
  ]
)
(C (w <Lit_Chars cat>))
(C
  (w <Lit_Chars echo>)
  (w
    (CommandSub
      left_token:<Left_DollarParen "$(">
      child:(C
        (w <Lit_Chars echo>)
        (w
          (word_part.ArithSub
            left:<Left_DollarDParen "$((">
            anode:(arith_expr.Binary
              op:<Arith_Star "*">
              left:(w <Lit_Digits 1>)
              right:(arith_expr.Binary
                op:<Arith_Plus "+">
                left:(w <Lit_Digits 2>)
                right:(w <Lit_Digits 3>)
              )
            )
            right:<Right_DollarDParen ")">
          )
        )
      )
      right:<Eof_RParen ")">
    )
  )
)
(command.CommandList
  children:[
    (command.Subshell
      left:<Op_LParen "(">
      child:(C
        (w <Lit_Chars echo>)
        (w
          (word_part.ArithSub
            left:<Left_DollarDParen "$((">
            anode:(arith_expr.Binary
              op:<Arith_Star "*">
              left:(w <Lit_Digits 1>)
              right:(arith_expr.Binary
                op:<Arith_Plus "+">
                left:(w <Lit_Digits 2>)
                right:(w <Lit_Digits 3>)
              )
            )
            right:<Right_DollarDParen ")">
          )
        )
      )
      right:<Right_Subshell ")">
      is_last_cmd:F
    )
  ]
)
(C
  (w <Lit_Chars echo>)
  (w
    (CommandSub
      left_token:<Left_DollarParen "$(">
      child:(C
        (w <Lit_Chars echo>)
        (w
          (word_part.ArithSub
            left:<Left_DollarDParen "$((">
            anode:(arith_expr.Binary
              op:<Arith_Plus "+">
              left:(w <Lit_Digits 1>)
              right:(w <Lit_Digits 2>)
            )
            right:<Right_DollarDParen ")">
          )
        )
      )
      right:<Eof_RParen ")">
    )
  )
)
(command.CommandList
  children:[
    (command.Subshell
      left:<Op_LParen "(">
      child:(C
        (w <Lit_Chars echo>)
        (w
          (word_part.ArithSub
            left:<Left_DollarDParen "$((">
            anode:(arith_expr.Binary
              op:<Arith_Plus "+">
              left:(w <Lit_Digits 1>)
              right:(w <Lit_Digits 2>)
            )
            ...right:<Right_DollarDParen ")">
          )
        )
      )
      right:<Right_Subshell ")">
      is_last_cmd:F
    )
  ]
)
(command.CommandList
  children:[
    (C
      (w <Lit_Chars echo>)
      (w
        (CommandSub
          left_token:<Left_DollarParen "$(">
          child:(command.ShAssignment
            left:<Lit_VarLike "array=">
            pairs:[
              (AssignPair
                left:...0x7f798d54ad00
                lhs:(sh_lhs.Name left:...0x7f798d54ad00 name:array)
                op:assign_op.Equal
                rhs:(w
                  (word_part.InitializerLiteral
                    left:<Op_LParen "(">
                    pairs:[
                      (InitializerWord.ArrayWord w:(w <Lit_Chars a>))
                      (InitializerWord.ArrayWord w:(w <Lit_Chars b>))
                      (InitializerWord.ArrayWord w:(w <Lit_Chars c>))
                    ]
                    right:<Right_Initializer ")">
                  )
                )
              )
            ]
          )
          right:<Eof_RParen ")">
        )
      )
    )
  ]
)
(command.CommandList
  children:[
    (command.Subshell
      left:<Op_LParen "(">
      child:(command.ShAssignment
        left:<Lit_VarLike "array=">
        pairs:[
          (AssignPair
            left:...0x7f798d54ae50
            lhs:(sh_lhs.Name left:...0x7f798d54ae50 name:array)
            op:assign_op.Equal
            rhs:(w
              (word_part.InitializerLiteral
                left:<Op_LParen "(">
                pairs:[
                  (InitializerWord.ArrayWord w:(w <Lit_Chars a>))
                  (InitializerWord.ArrayWord w:(w <Lit_Chars b>))
                  (InitializerWord.ArrayWord w:(w <Lit_Chars c>))
                ]
                right:<Right_Initializer ")">
              )
            )
          )
        ]
      )
      right:<Right_Subshell ")">
      is_last_cmd:F
    )
  ]
)
(command.CommandList
  children:[
    (C
      (w
        (CommandSub
          left_token:<Left_DollarParen "$(">
          child:(command.Case
            case_kw:<KW_Case case>
            to_match:(case_arg.Word w:(w <Lit_Chars foo>))
            arms_start:<KW_In in>
            arms:[
              (CaseArm
                left:<Op_LParen "(">
                pattern:(pat.Words words:[(w <Lit_Chars one>)])
                middle:<Right_CasePat ")">
                action:[(C (w <Lit_Chars echo>) (w <Lit_Chars hi>))]
                right:<Op_DSemi ";;">
              )
            ]
            arms_end:<KW_Esac esac>
          )
          right:<Eof_RParen ")">
        )
      )
    )
  ]
)
(command.CommandList
  children:[
    (command.Subshell
      left:<Op_LParen "(">
      child:(command.Case
        case_kw:<KW_Case case>
        to_match:(case_arg.Word w:(w <Lit_Chars foo>))
        arms_start:<KW_In in>
        arms:[
          (CaseArm
            left:<Op_LParen "(">
            pattern:(pat.Words words:[(w <Lit_Chars one>)])
            middle:<Right_CasePat ")">
            action:[(C (w <Lit_Chars echo>) (w <Lit_Chars hi>))]
            right:<Op_DSemi ";;">
          )
        ]
        arms_end:<KW_Esac esac>
      )
      right:<Right_Subshell ")">
      is_last_cmd:F
    )
  ]
)
(command.CommandList
  children:[
    (C
      (w <Lit_Chars echo>)
      (w
        (CommandSub
          left_token:<Left_DollarParen "$(">
          child:(command.Case
            case_kw:<KW_Case case>
            to_match:(case_arg.Word w:(w <Lit_Chars foo>))
            arms_start:<KW_In in>
            arms:[
              (CaseArm
                left:<Lit_Chars one>
                pattern:(pat.Words words:[(w <Lit_Chars one>)])
                middle:<Right_CasePat ")">
                action:[(C (w <Lit_Chars echo>) (w <Lit_Chars comsub>))]
                right:<Op_DSemi ";;">
              )
            ]
            arms_end:<KW_Esac esac>
          )
          right:<Eof_RParen ")">
        )
      )
    )
  ]
)
(command.CommandList
  children:[
    (C
      (w <Lit_Chars echo>)
      (w
        (CommandSub
      ....    left_token:<Left_DollarParen "$(">
          child:(command.CommandList
            children:[
              (command.Case
                case_kw:<KW_Case case>
                to_match:(case_arg.Word w:(w <Lit_Chars foo>))
                arms_start:<KW_In in>
                arms:[
                  (CaseArm
                    left:<Lit_Chars one>
                    pattern:(pat.Words words:[(w <Lit_Chars one>)])
                    middle:<Right_CasePat ")">
                    action:[(C (w <Lit_Chars echo>) (w <Lit_Chars comsub1>))]
                    right:<Op_DSemi ";;">
                  )
                ]
                arms_end:<KW_Esac esac>
              )
              (command.Case
                case_kw:<KW_Case case>
                to_match:(case_arg.Word w:(w <Lit_Chars bar>))
                arms_start:<KW_In in>
                arms:[
                  (CaseArm
                    left:<Lit_Chars two>
                    pattern:(pat.Words words:[(w <Lit_Chars two>)])
                    middle:<Right_CasePat ")">
                    action:[(C (w <Lit_Chars echo>) (w <Lit_Chars comsub2>))]
                    right:<Op_DSemi ";;">
                  )
                ]
                arms_end:<KW_Esac esac>
              )
            ]
          )
          right:<Eof_RParen ")">
        )
      )
    )
  ]
)
(C
  (w <Lit_Chars echo>)
  (w
    (DQ
      <Lit_Chars "double ">
      (CommandSub
        left_token:<Left_DollarParen "$(">
        child:(C (w <Lit_Chars echo>) (w <Lit_Chars hi>))
        right:<Eof_RParen ")">
      )
      <Lit_Chars " quoted">
    )
  )
  (w <Lit_Chars two>)
)
(command.CommandList
  children:[
    (command.Sentence
      child:(C (w <Lit_Chars echo>) (w <Lit_Chars one>))
      terminator:<Op_Semi ";">
    )
    (command.Sentence
      child:(C
        (w <Lit_Chars echo>)
        (w
          (CommandSub
            left_token:<Left_DollarParen "$(">
            child:(command.Case
              case_kw:<KW_Case case>
              to_match:(case_arg.Word w:(w <Lit_Chars one>))
              arms_start:<KW_In in>
              arms:[
                (CaseArm
                  left:<Left_DollarParen "$(">
                  pattern:(pat.Words
                    words:[
                      (w
                        (CommandSub
                          left_token:<Left_DollarParen "$(">
                          child:(C (w <Lit_Chars echo>) (w <Lit_Chars one>))
                          right:<Eof_RParen ")">
                        )
                      )
                    ]
                  )
                  middle:<Right_CasePat ")">
                  action:[
                    (C
                      (w <Lit_Chars echo>)
                      (w
                        (CommandSub
                          left_token:<Left_DollarParen "$(">
                          child:(C (w <Lit_Chars comsub>))
                          right:<Eof_RParen ")">
                        )
                      )
                    )
                  ]
                  right:<Op_DSemi ";;">
                )
              ]
              arms_end:<KW_Esac esac>
            )
            right:<Eof_RParen ")">
          )
        )
      )
      terminator:<Op_Semi ";">
    )
    (C (w <Lit_Chars echo>) (w <Lit_Chars two>))
  ]
)
(command.CommandList
  children:[
    (command.Subshell
      left:<Op_LParen "(">
      child:(command.Case
        case_kw:<KW_Case case>
        to_match:(case_arg.Word w:(w <Lit_Chars foo>))
        arms_start:<KW_In in>
        arms:[]
        arms_end:<KW_Esac esac>
      )
      right:<Right_Subshell ")">
      is_last_cmd:F
    )
  ]
)
(command.CommandList
  children:[
    (C
      (w
        (CommandSub
          left_token:<Left_DollarParen "$(">
          child:(command.ForExpr
            keyword:<KW_For for>
            init:(arith_expr.BinaryAssign
              op_id:Arith_Equal
              left:<Lit_ArithVarLike i>
              right:(w <Lit_Digits 0>)
            )
            cond:(arith_expr.Binary
            .....  op:<Arith_Less "<">
              left:<Lit_ArithVarLike i>
              right:(w <Lit_Digits 3>)
            )
            update:(arith_expr.UnaryAssign
              op_id:Arith_DPlus
              child:<Lit_ArithVarLike i>
            )
            body:(command.DoGroup
              left:<KW_Do do>
              children:[(C (w <Lit_Chars echo>) (w <Lit_Chars hi>))]
              right:<KW_Done done>
            )
          )
          right:<Eof_RParen ")">
        )
      )
    )
  ]
)
(command.CommandList
  children:[
    (command.Subshell
      left:<Op_LParen "(">
      child:(command.ForExpr
        keyword:<KW_For for>
        init:(arith_expr.BinaryAssign
          op_id:Arith_Equal
          left:<Lit_ArithVarLike i>
          right:(w <Lit_Digits 0>)
        )
        cond:(arith_expr.Binary
          op:<Arith_Less "<">
          left:<Lit_ArithVarLike i>
          right:(w <Lit_Digits 3>)
        )
        update:(arith_expr.UnaryAssign
          op_id:Arith_DPlus
          child:<Lit_ArithVarLike i>
        )
        body:(command.DoGroup
          left:<KW_Do do>
          children:[(C (w <Lit_Chars echo>) (w <Lit_Chars hi>))]
          right:<KW_Done done>
        )
      )
      right:<Right_Subshell ")">
      is_last_cmd:F
    )
  ]
)
(C
  (w <Lit_Chars echo>)
  (w
    (word_part.ArithSub
      left:<Left_DollarDParen "$((">
      anode:(arith_expr.BinaryAssign
        op_id:Arith_Equal
        left:(arith_expr.Binary
          op:<Arith_LBracket "[">
          left:<Lit_ArithVarLike a>
          right:(arith_expr.Binary
            op:<Arith_Star "*">
            left:(w <Lit_Digits 1>)
            right:(arith_expr.Binary
              op:<Arith_Plus "+">
              left:(w <Lit_Digits 2>)
              right:(w <Lit_Digits 3>)
            )
          )
        )
        right:<Lit_ArithVarLike x>
      )
      right:<Right_DollarDParen ")">
    )
  )
)
(C
  (w <Lit_Chars echo>)
  (w
    (CommandSub
      left_token:<Left_DollarParen "$(">
      child:(C
        (w
          <Lit_Chars one>
          (CommandSub
            left_token:<Left_DollarParen "$(">
            child:(C (w <Lit_Chars echo>) (w <Lit_Chars two>))
            right:<Eof_RParen ")">
          )
          <Lit_Chars one>
        )
      )
      right:<Eof_RParen ")">
    )
  )
  (w <Lit_Chars three>)
)
(BraceGroup
  left:<Lit_LBrace "{">
  children:[
    (command.Sentence
      child:(C (w <Lit_Chars cd>) (w <Lit_Slash />))
      terminator:<Op_Semi ";">
    )
    (command.Sentence
      child:(C (w <Lit_Chars echo>) (w <Lit_Chars PWD>))
      terminator:<Op_Semi ";">
    )
  ]
  right:<Lit_RBrace "}">
)
(command.CommandList
  children:[
    (command.Sentence
      child:(BraceGroup
        left:<Lit_LBrace "{">
        children:[
          (command.Sentence
            child:(C (w <Lit_Chars cd>) (w <Lit_Slash />))
            terminator:<Op_Semi ";">
          )
          (command.Sentence
            child:(C (w <Lit_Chars echo>) (w <Lit_Chars PWD>))
            terminator:<Op_Semi ";">
          )
        ]
        right:<Lit_RBrace "}">
      )
      terminator:<Op_Semi ";">
    )
    (C (w <Lit_Chars echo>) (w <Lit_Chars PWD>))
  ]
)
(command.CommandList
  children:[
    (command.Sentence
      child:(command.Subshell
        left:<Op_LParen "(">
        child:(command.CommandList
          children:[
            (command.Sentence
              child:(C (w <Lit_Chars cd>) (w <Lit_Slash />))
              terminator:<Op_Semi ";">
            )
            (C (w <Lit_Chars echo>) (w <Lit_Chars PWD>) (w <Lit_Number 1>))
          ]
        )
        right:<Right_Subshell ")">
        is_last_cmd:F
      )
      terminator:<Op_Semi ";">
    )
    (C (w <Lit_Chars echo>) (w <Lit_Chars PWD>) (w <Lit_Number 2>))
  ]
)
(command.CommandList
  children:[
    (C
      (w <Lit_Chars echo>)
      (w
        (CommandSub
          left_token:<Left_DollarParen "$(">
          child:(command.CommandList
            children:[
              (command.Sentence
                child:(ShFunction
                  name_tok:<Lit_Chars f...un>
                  name:fun
                  body:(BraceGroup
                    left:<Lit_LBrace "{">
                    children:[
                      (command.Sentence
                        child:(C (w <Lit_Chars echo>) (w <Lit_Chars hi>))
                        terminator:<Op_Semi ";">
                      )
                    ]
                    right:<Lit_RBrace "}">
                  )
                  code_str:"fun() { echo hi; }"
                )
                terminator:<Op_Semi ";">
              )
              (C (w <Lit_Chars fun>))
            ]
          )
          right:<Eof_RParen ")">
        )
      )
    )
  ]
)
(command.CommandList
  children:[
    (command.Subshell
      left:<Op_LParen "(">
      child:(command.CommandList
        children:[
          (command.Sentence
            child:(ShFunction
              name_tok:<Lit_Chars fun>
              name:fun
              body:(BraceGroup
                left:<Lit_LBrace "{">
                children:[
                  (command.Sentence
                    child:(C (w <Lit_Chars echo>) (w <Lit_Chars hi>))
                    terminator:<Op_Semi ";">
                  )
                ]
                right:<Lit_RBrace "}">
              )
              code_str:"fun() { echo hi; }"
            )
            terminator:<Op_Semi ";">
          )
          (C (w <Lit_Chars fun>))
        ]
      )
      right:<Right_Subshell ")">
      is_last_cmd:F
    )
  ]
)
(command.CommandList
  children:[
    (command.Sentence
      child:(C (w <Lit_Chars echo>) (w <Lit_Chars one>))
      terminator:<Op_Semi ";">
    )
    (command.Sentence
      child:(C
        (w <Lit_Chars echo>)
        (w
          (CommandSub
            left_token:<Left_DollarParen "$(">
            child:(command.CommandList
              children:[
                (command.Sentence
                  child:(command.Subshell
                    left:<Op_LParen "(">
                    child:(command.CommandList
                      children:[
                        (command.Sentence
                          child:(C (w <Lit_Chars cd>) (w <Lit_Slash />))
                          terminator:<Op_Semi ";">
                        )
                        (C (w <Lit_Chars echo>) (w <Lit_Chars subshell_PWD>))
                      ]
                    )
                    right:<Right_Subshell ")">
                    is_last_cmd:F
                  )
                  terminator:<Op_Semi ";">
                )
                (C (w <Lit_Chars echo>) (w <Lit_Chars comsub_PWD>))
              ]
            )
            right:<Eof_RParen ")">
          )
        )
      )
      terminator:<Op_Semi ";">
    )
    (C (w <Lit_Chars echo>) (w <Lit_Chars two>))
  ]
)
(command.CommandList
  children:[
    (C
      (w
        (CommandSub
          left_token:<Left_DollarParen "$(">
          child:(command.Case
            case_kw:<KW_Case case>
            to_match:(case_arg.Word w:(w <Lit_Chars foo>))
            arms_start:<KW_In in>
            arms:[
              (CaseArm
                left:<Lit_Chars one>
                pattern:(pat.Words words:[(w <Lit_Chars one>)])
                middle:<Right_CasePat ")">
                action:[(C (w <Lit_Chars echo>) (w <Lit_Chars hi>))]
                right:<Op_DSemi ";;">
              )
            ]
            arms_end:<KW_Esac esac>
          )
          right:<Eof_RParen ")">
        )
      )
    )
  ]
)
(command.CommandList
  children:[
    (command.Subshell
      left:<Op_LParen "(">
      child:(command.Case
        case_kw:<KW_Case case>
        to_match:(case_arg.Word w:(w <Lit_Chars foo>))
        arms_start:<KW_In in>
        arms:[
          (CaseArm
            left:<Lit_Chars one>
            pattern:(pat.Words words:[(w <Lit_Chars one>)])
            middle:<Right_CasePat ")">
            action:[(C (w <Lit_Chars echo>) (w <Lit_Chars hi>))]
            right:<Op_DSemi ";;">
          )
        ]
        arms_end:<KW_Esac esac>
      )
      right:<Right_Subshell ")">
      is_last_cmd:F
    )
  ]
)
(C.....  errcmd=( "${SETUP_STATE[$err.cmd]}" )
                              ^
"<cmd_parse_test>":1: Unexpected token while parsing arithmetic: '.'
...
  (w <Lit_Chars echo>)
  (w
    <Lit_Chars ab>
    (CommandSub
      left_token:<Left_DollarParen "$(">
      child:(C (w <Lit_Chars echo>) (w <Lit_Chars hi>))
      right:<Eof_RParen ")">
    )
    <Lit_Chars cd>
  )
  (w <Lit_Chars ef>)
)
(command.CommandList
  children:[
    (command.Sentence
      child:(command.DBracket
        left:<KW_DLeftBracket "[[">
        expr:(bool_expr.Unary
          op_id:BoolUnary_n
          child:(w
            (DQ
              (BracedVarSub
                left:<Left_DollarBrace "${">
                name_tok:<VSub_Name marks>
                var_name:marks
                bracket_op:(bracket_op.ArrayIndex
                  expr:(w
                    (${ VSub_Name tag_marker)
                    <Lit_Digits 002>
                    (${ VSub_Name cons_ptr)
                  )
                )
                right:<Right_DollarBrace "}">
              )
            )
          )
        )
        right:<Lit_DRightBracket "]]">
      )
      terminator:<Op_Semi ";">
    )
  ]
)
(command.CommandList
  children:[
    (C
      (w <Lit_Chars echo>)
      (w
        (word_part.ArithSub
          left:<Left_DollarDParen "$((">
          anode:(w <Lit_Digits 0> <Lit_ArithVarLike x> ($ foo))
          right:<Right_DollarDParen ")">
        )
      )
    )
  ]
)
(command.CommandList
  children:[
    (command.ShAssignment
      left:<Lit_VarLike "errcmd=">
      pairs:[
        (AssignPair
          left:...0x7f798d53b130
          lhs:(sh_lhs.Name left:...0x7f798d53b130 name:errcmd)
          op:assign_op.Equal
          rhs:(w
            (word_part.InitializerLiteral
              left:<Op_LParen "(">
              pairs:[
                (InitializerWord.ArrayWord
                  w:(w
                    (DQ
                      (BracedVarSub
                        left:<Left_DollarBrace "${">
                        name_tok:<VSub_Name SETUP_STATE>
                        var_name:SETUP_STATE
                        bracket_op:(bracket_op.ArrayIndex
                          expr:(w (DQ ($ err) <Lit_Chars .cmd>))
                        )
                        right:<Right_DollarBrace "}">
                      )
                    )
                  )
                )
              ]
              right:<Right_Initializer ")">
            )
          )
        )
      ]
    )
  ]
)
(command.CommandList
  children:[
    (C
      (w <Lit_Chars echo>)
      (w
        (CommandSub
          left_token:<Left_DollarParen "$(">
          child:(command.NoOp)
          right:<Eof_RParen ")">
        )
      )
    )
  ]
)
(command.CommandList
  children:[
    (C
      (w <Lit_Chars echo>)
      (w
        (CommandSub
          left_token:<Left_Backtick "`">
          child:(command.NoOp)
          right:<Backtick_Right "`">
        )
      )
    )
  ]
)
(command.CommandList
  children:[
    (C
      (w <Lit_Chars cmd>)
      (w <Lit_Chars flag>)
      (w
        (CommandSub
          left_token:<Left_Backtick "`">
          child:(command.NoOp)
          right:<Backtick_Right "`">
        )
      )
      (w <Lit_Chars flag2>)
    )
  ]
)
(command.CommandList
  children:[
    (command.ShAssignment
      left:<Lit_VarLike "FOO=">
      pairs:[
        (AssignPair
          left:...0x7f798d69ef30
          lhs:(sh_lhs.Name left:...0x7f798d69ef30 name:FOO)
          op:assign_op.Equal
          rhs:(w
            (DQ <Lit_Chars bar>)
            (CommandSub
              left_token:<Left_Backtick "`">
              child:(command.NoOp)
              right:<Backtick_Right "`">
            )
            (DQ <Lit_Chars baz>)
          )
        )
      ]
    )
  ]
)
(command.CommandList
  children:[
    (command.If
      if_kw:<KW_If if>
      arms:[
        (IfArm
          keyword:...0x7f798d54aad0
          cond:(List_of_command
            (command.Sentence
              child:(C (w <Lit_Chars "true">))
              terminator:<Op_Semi ";">
            )
          )
          then_kw:<KW_Then then>
          action:[
            (command.Subshell
              left:<Op_LParen "(">
      .        child:(C (w <Lit_Chars echo>) (w <Lit_Chars hi>))
              right:<Right_Subshell ")">
              is_last_cmd:F
            )
          ]
          then_tok:...0x7f798d54ac90
        )
      ]
      else_action:[]
      fi_kw:<KW_Fi fi>
    )
  ]
)
(command.CommandList
  children:[
    (command.WhileUntil
      keyword:<KW_While while>
      cond:(List_of_command
        (command.Sentence
          child:(C (w <Lit_Chars "true">))
          terminator:<Op_Semi ";">
        )
      )
      body:(command.DoGroup
        left:<KW_Do do>
        children:[
          (BraceGroup
            left:<Lit_LBrace "{">
            children:[
              (C (w <Lit_Chars echo>) (w <Lit_Chars hi>))
              (command.ControlFlow keyword:<ControlFlow_Break break>)
            ]
            right:<Lit_RBrace "}">
          )
        ]
        right:<KW_Done done>
      )
    )
  ]
)
(command.CommandList
  children:[
    (command.If
      if_kw:<KW_If if>
      arms:[
        (IfArm
          keyword:...0x7f798d54a980
          cond:(List_of_command
            (command.Sentence
              child:(C (w <Lit_Chars "true">))
              terminator:<Op_Semi ";">
            )
          )
          then_kw:<KW_Then then>
          action:[
            (command.Subshell
              left:<Op_LParen "(">
              child:(C (w <Lit_Chars echo>) (w <Lit_Chars hi>))
              right:<Right_Subshell ")">
              is_last_cmd:F
            )
          ]
          then_tok:...0x7f798d487750
        )
      ]
      else_action:[]
      fi_kw:<KW_Fi fi>
    )
  ]
)
(command.CommandList
  children:[
    (command.If
      if_kw:<KW_If if>
      arms:[
        (IfArm
          keyword:...0x7f798d487de0
          cond:(List_of_command
            (command.Sentence
              child:(C (w <Lit_Chars "true">))
              terminator:<Op_Semi ";">
            )
          )
          then_kw:<KW_Then then>
          action:[
            (command.If
              if_kw:<KW_If if>
              arms:[
                (IfArm
                  keyword:...0x7f798d4f6280
                  cond:(List_of_command
                    (command.Sentence
                      child:(C (w <Lit_Chars "true">))
                      terminator:<Op_Semi ";">
                    )
                  )
                  then_kw:<KW_Then then>
                  action:[(C (w <Lit_Chars echo>) (w <Lit_Chars hi>))]
                  then_tok:...0x7f798d4f6520
                )
              ]
              else_action:[]
              fi_kw:<KW_Fi fi>
            )
          ]
          then_tok:...0x7f798d4f6130
        )
      ]
      else_action:[]
      fi_kw:<KW_Fi fi>
    )
    (C (w <Lit_Chars echo>) (w <Lit_Chars hi>))
  ]
)
(command.CommandList
  children:[
    (command.Subshell
      left:<Op_LParen "(">
      child:(command.AndOr
        children:[
          (C (w <Lit_Chars cd>) (w (DQ ($ PACKDIR))))
          (command.ForEach
            keyword:<KW_For for>
            iter_names:[e]
            iterable:(for_iter.Words words:[(w ($ existing))])
            body:(command.DoGroup
              left:<KW_Do do>
              children:[
                (command.Case
                  case_kw:<KW_Case case>
                  to_match:(case_arg.Word
                    w:(w (DQ <Lit_Chars " "> ($ fullbases) <Lit_Chars " ">))
                  )
                  arms_start:<KW_In in>
                  arms:[
                    (CaseArm
                      left:<Lit_Star "*">
                      pattern:(pat.Words
                        words:[
                          (w
                            <Lit_Star "*">
                            (DQ <Lit_Chars " "> ($ e) <Lit_Chars " ">)
                            <Lit_Star "*">
                          )
                        ]
                      )
                      middle:<Right_CasePat ")">
                      action:[]
                      right:<Op_DSemi ";;">
                    )
                    (CaseArm
                      left:<Lit_Star "*">
          ............            pattern:(pat.Words words:[(w <Lit_Star "*">)])
                      middle:<Right_CasePat ")">
                      action:[
                        (C
                          (w <Lit_Chars rm>)
                          (w <Lit_Chars -f>)
                          (w (DQ ($ e) <Lit_Chars .pack>))
                          (w (DQ ($ e) <Lit_Chars .idx>))
                          (w (DQ ($ e) <Lit_Chars .keep>))
                        )
                      ]
                      right:<Op_DSemi ";;">
                    )
                  ]
                  arms_end:<KW_Esac esac>
                )
              ]
              right:<KW_Done done>
            )
          )
        ]
        ops:[<Op_DAmp "&&">]
      )
      right:<Right_Subshell ")">
      is_last_cmd:F
    )
  ]
)
(command.CommandList
  children:[
    (command.Sentence
      child:(C
        (w <Lit_Chars .>)
        (w (DQ ($ TEST_DIRECTORY)) <Lit_Slash /> <Lit_Chars diff-lib.sh>)
      )
      terminator:<Op_Semi ";">
    )
  ]
)
(command.CommandList
  children:[
    (C (w <Lit_Chars echo>) (w <Lit_Chars foo> <Lit_Pound "#"> <Lit_Chars bar>))
  ]
)
(command.CommandList children:[(C (w <Lit_Chars echo>) (w <Lit_Chars foo>))])
(command.CommandList children:[(C (w <Lit_Chars echo>) (w <Lit_Chars foo>))])
(command.Case
  case_kw:<KW_Case case>
  to_match:(case_arg.Word w:(w (DQ ($ fd) <Lit_Chars ","> ($ command))))
  arms_start:<KW_In in>
  arms:[
    (CaseArm
      left:<Lit_Number 3>
      pattern:(pat.Words
        words:[
          (w <Lit_Number 3> <Lit_Comma ","> <Lit_Pound "#"> <Lit_Star "*">)
          (w <Lit_Number 3> <Lit_Comma ",">)
        ]
      )
      middle:<Right_CasePat ")">
      action:[]
      right:<Op_DSemi ";;">
    )
  ]
  arms_end:<KW_Esac esac>
)
(command.CommandList
  children:[
    (command.Case
      case_kw:<KW_Case case>
      to_match:(case_arg.Word w:(w <Lit_Chars foo>))
      arms_start:<KW_In in>
      arms:[
        (CaseArm
          left:<Left_DollarSingleQuote "$'">
          pattern:(pat.Words
            words:[
              (w
                (SingleQuoted
                  left:<Left_DollarSingleQuote "$'">
                  sval:"'"
                  right:<Right_SingleQuote "'">
                )
              )
            ]
          )
          middle:<Right_CasePat ")">
          action:[
            (command.ShAssignment
              left:<Lit_VarLike "ret+=">
              pairs:[
                (AssignPair
                  left:...0x7f798d487f30
                  lhs:(sh_lhs.Name left:...0x7f798d487f30 name:ret)
                  op:assign_op.PlusEqual
                  rhs:(w
                    (DQ
                      (word_part.EscapedLiteral
                        token:<Lit_EscapedChar "\\\\">
                        ch:"\\"
                      )
                    )
                    (word_part.EscapedLiteral
                      token:<Lit_EscapedChar "\\'">
                      ch:"'"
                    )
                  )
                )
              ]
            )
          ]
          right:<Op_DSemi ";;">
        )
      ]
      arms_end:<KW_Esac esac>
    )
  ]
)
(command.CommandList
  children:[
    (C
      (w
        (SingleQuoted
          left:<Left_DollarSingleQuote "$'">
          sval:"abc\ndef"
          right:<Right_SingleQuote "'">
        )
      )
    )
  ]
)
(C (w <Lit_Chars echo>) (w <Lit_Chars hi>))
(Redir op:<Redir_GreatAnd ">&"> loc:(redir_loc.Fd fd:1) arg:(w <Lit_Number 2>))
(Redir
  op:<Redir_DLess "<<">
  loc:(redir_loc.Fd fd:0)
  arg:(redir_param.HereDoc here_begin:(w <Lit_Chars EOF>) stdin_parts:[])
)
(Redir
  op:<Redir_DLessDash "<<-">
  loc:(redir_loc.Fd fd:0)
  arg:(redir_param.HereDoc here_begin:(w <Lit_Chars EOF>) stdin_parts:[])
)
(C (w <Lit_Chars cat>))
(Redir op:<Redir_Great ">"> loc:(redir_loc.Fd fd:1) arg:(w <Lit_Chars out.txt>))
(Redir
  op:<Redir_DLess "<<">
  loc:(redir_loc.Fd fd:0)
  arg:(redir_param.HereDoc here_begin:(w <Lit_Chars EOF>) stdin_parts:[])
)
(C (w <Lit_Chars cat>))
(C (w <Lit_Chars cat>))
(com......
======================================================================
FAIL: testUnquotedHereDoc (__main__.HereDocTest)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "/home/uke/oil/osh/cmd_parse_test.py", line 222, in testUnquotedHereDoc
    self.assertEqual(4, len(h.stdin_parts))
AssertionError: 4 != 3

----------------------------------------------------------------------
Ran 83 tests in 0.413s

FAILED (failures=1)
mand.CommandList
  children:[
    (command.ShAssignment
      left:<Lit_VarLike "ONE=">
      pairs:[
        (AssignPair
          left:...0x7f798d487ec0
          lhs:(sh_lhs.Name left:...0x7f798d487ec0 name:ONE)
          op:assign_op.Equal
          rhs:(w <Lit_Number 1>)
        )
        (AssignPair
          left:<Lit_VarLike "TWO=">
          lhs:(sh_lhs.Name left:...0x7f798d487a60 name:TWO)
          op:assign_op.Equal
          rhs:(w <Lit_Number 2>)
        )
      ]
    )
  ]
)
(command.CommandList
  children:[
    (command.Redirect
      child:(command.NoOp)
      redirects:[
        (Redir
          op:<Redir_Great ">">
          loc:(redir_loc.Fd fd:1)
          arg:(w <Lit_Chars out.txt>)
        )
      ]
    )
  ]
)
(C
  (w <Lit_Chars echo>)
  (w (DQ <Lit_Chars one>) <Lit_Chars two>)
  (w (DQ <Lit_Chars three>) (DQ <Lit_Chars four>))
  (w <Lit_Chars five>)
)
(command.CommandList
  children:[
    (command.Simple
      blame_tok:<Lit_Chars env>
      more_env:[
        (EnvPair
          left:<Lit_VarLike "PYTHONPATH=">
          name:PYTHONPATH
          val:(w <Lit_Chars .>)
        )
      ]
      words:[(w <Lit_Chars env>)]
      is_last_cmd:F
      redirects:[
        (Redir
          op:<Redir_Great ">">
          loc:(redir_loc.Fd fd:1)
          arg:(w <Lit_Chars out.txt>)
        )
      ]
    )
  ]
)
(command.CommandList
  children:[
    (C
      (w <Lit_Chars echo>)
      (w <Lit_Number 1>)
      (w <Lit_Number 2>)
      (w <Lit_Number 3>)
    )
  ]
)
(C (w <Lit_Chars ls>) (w <Lit_Chars foo>))
(command.Simple
  blame_tok:<Lit_Chars ls>
  more_env:[
    (EnvPair left:<Lit_VarLike "FOO="> name:FOO val:(w <Lit_Chars bar>))
  ]
  words:[(w <Lit_Chars ls>) (w <Lit_Chars foo>)]
  is_last_cmd:F
)
(command.Simple
  blame_tok:<Lit_Chars ls>
  more_env:[
    (EnvPair left:<Lit_VarLike "FOO="> name:FOO val:(w <Lit_Chars bar>))
    (EnvPair left:<Lit_VarLike "SPAM="> name:SPAM val:(w <Lit_Chars eggs>))
  ]
  words:[(w <Lit_Chars ls>) (w <Lit_Chars foo>)]
  is_last_cmd:F
  redirects:[
    (Redir
      op:<Redir_Great ">">
      loc:(redir_loc.Fd fd:1)
      arg:(w <Lit_Chars output.txt>)
    )
  ]
)
(command.Simple
  blame_tok:<Lit_Chars ls>
  more_env:[
    (EnvPair left:<Lit_VarLike "FOO="> name:FOO val:(w <Lit_Chars bar>))
    (EnvPair left:<Lit_VarLike "SPAM="> name:SPAM val:(w <Lit_Chars eggs>))
  ]
  words:[(w <Lit_Chars ls>) (w <Lit_Chars foo>)]
  is_last_cmd:F
  redirects:[
    (Redir
      op:<Redir_Great ">">
      loc:(redir_loc.Fd fd:1)
      arg:(w <Lit_Chars output.txt>)
    )
    (Redir
      op:<Redir_Great ">">
      loc:(redir_loc.Fd fd:1)
      arg:(w <Lit_Chars output2.txt>)
    )
  ]
)

FAIL: osh/cmd_parse_test.py with code 1