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:...0x7f3a1a51d530
          lhs:(sh_lhs.Name left:...0x7f3a1a51d530 name:empty)
          op:assign_op.Equal
          rhs:(w
            (ShArrayLiteral
              left:<Op_LParen "(">
              words:[]
              right:<Right_ShArrayLiteral ")">
            )
          )
        )
      ]
    )
  ]
)
(command.CommandList
  children:[
    (command.ShAssignment
      left:<Lit_VarLike "array=">
      pairs:[
        (AssignPair
          left:...0x7f3a1a51d738
          lhs:(sh_lhs.Name left:...0x7f3a1a51d738 name:array)
          op:assign_op.Equal
          rhs:(w
            (ShArrayLiteral
              left:<Op_LParen "(">
              words:[(w <Lit_Chars a>) (w <Lit_Chars b>) (w <Lit_Chars c>)]
              right:<Right_ShArrayLiteral ")">
            )
          )
        )
      ]
    )
  ]
)
(command.CommandList
  children:[
    (command.Sentence
      child:(command.ShAssignment
        left:<Lit_VarLike "array=">
        pairs:[
          (AssignPair
            left:...0x7f3a1a51dbb0
            lhs:(sh_lhs.Name left:...0x7f3a1a51dbb0 name:array)
            op:assign_op.Equal
            rhs:(w
              (ShArrayLiteral
                left:<Op_LParen "(">
                words:[(w <Lit_Chars a>) (w <Lit_Chars b>) (w <Lit_Chars c>)]
                right:<Right_ShArrayLiteral ")">
              )
            )
          )
        ]
      )
      terminator:<Op_Semi ";">
    )
    (command.ShAssignment
      left:<Lit_VarLike "array2=">
      pairs:[
        (AssignPair
          left:...0x7f3a1a51dae0
          lhs:(sh_lhs.Name left:...0x7f3a1a51dae0 name:array2)
          op:assign_op.Equal
          rhs:(w
            (ShArrayLiteral
              left:<Op_LParen "(">
              words:[(w <Lit_Chars d>) (w <Lit_Chars e>) (w <Lit_Chars f>)]
              right:<Right_ShArrayLiteral ")">
            )
          )
        )
      ]
    )
  ]
)
(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:[...0x7f3a1a504188])
    (CompoundWord
      parts:[(Token id:Lit_Chars length:3 col:3 line:...0x7f3a1a520aa0)]
    )
  ]
  is_last_cmd:F
)

(command.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:...0x7f3a1a520ec0)
    children:[
      (command.Sentence
        child:(command.Simple
          blame_tok:(Token id:Lit_Chars length:4 col:8 line:...0x7f3a1a520ec0)
          more_env:[]
          words:[
            (CompoundWord parts:[...0x7f3a1a510b48])
            (CompoundWord
              parts:[
                (Token id:Lit_Chars length:2 col:13 line:...0x7f3a1a520ec0)
              ]
            )
          ]
          is_last_cmd:F
        )
        terminator:(Token id:Op_Semi length:1 col:15 line:...0x7f3a1a520ec0)
      )
    ]
    right:(Token id:Lit_RBrace length:1 col:17 line:...0x7f3a1a520ec0)
  )
)

(C
  (w <Lit_Chars echo>)
  (w
    (CommandSub
      left_token:<Left_DollarParen "$(">
      child:(C (w <Lit_Chars echo>) (w <Lit_Chars 12>))
      right:<Eof_RParen ")">
    )
    (CommandSub
      left_token:<Left_DollarParen "$(">
      child:(C (w <Lit_Chars echo>) (w <Lit_Chars 34>))
      right:<Eof_RParen ")">
    )
  )
)
(C
  (w <Lit_Chars echo>)
  (w
    (DQ
      (CommandSub
        left_token:<Left_DollarParen "$(">
        child:(C (w <Lit_Chars echo>) (w <Lit_Chars 12>))
        right:<Eof_RParen ")">
      )
      (CommandSub
        left_token:<Left_DollarParen "$(">
        child:(C (w <Lit_Chars echo>) (w <Lit_Chars 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:...0x7f3a1....a51ddb8
          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:...0x7f3a1a51d530
        )
      ]
      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_Chars 1>) (w <Lit_Chars 2>) (w <Lit_Chars 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:...0x7f3a1a82f710
      body:(command.DoGroup
        left:<KW_Do do>
        children:[(C (w <Lit_Chars echo>) (w ($ i)))]
        right:<KW_Done done>
      )
    )
  ]
)
(command.CommandList
  children:[
    (command.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 "}">
      )
    )
  ]
)
(command.CommandList
  children:[
    (command.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
      )
    )
  ]
)
(command.CommandList
  children:[
    (command.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:[
    (command.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 "}">
      )
    )
  ]
)
(command.CommandList
  children:[
    (command.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 "}">
      )
    )
  ]
)
(command.CommandList
  children:[
    (command.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
      )
    )
  ]
)
(command.CommandList
  children:[
    (command.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:[
    (command.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:[
    (command.ShFun...  ls foo|
         ^
"<cmd_parse_test>":1: Unexpected EOF while parsing command
..ction
      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 "1>&">
            loc:(redir_loc.Fd fd:1)
            arg:(w <Lit_Chars 2>)
          )
          (Redir
            op:<Redir_Great "2>">
            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:...0x7f3a1a552a78
          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:...0x7f3a1a510a10
        )
      ]
      else_action:[]
      fi_kw:<KW_Fi fi>
    )
  ]
)
(command.CommandList
  children:[
    (command.If
      if_kw:<KW_If if>
      arms:[
        (IfArm
          keyword:...0x7f3a1a510bb0
          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:...0x7f3a1a510d50
        )
      ]
      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:...0x7f3a1a48b870
        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:...0x7f3a1a3d40b8
        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:[(command.Expr 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:...0x7f3a1a45cd50
        regex:(SQ eggex)
        flags:[]
        canonical_flags:""
      )
      middle:<Lit_LBrace "{">
      action:[(command.Expr 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:[(command.Expr 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:[(command.Expr keyword:<Lit_Equals "="> e:(Var x))]
      right:<Lit_RBrace "}">
    )
  ]
  arms_end:<Lit_RBrace "}">
)
(command.Redirect
  child:(C (w <Lit_Chars ls>) (w <Lit_Chars foo>))
  redirects:[
    (Redir
      op:<Redir_Great "2>">
      loc:(redir_loc.Fd fd:2)
      arg:(w <Lit_Slash /> <Lit_Chars dev> <Lit_Slash /> <Lit_Chars "null">)
    )
  ]
)
(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.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.Pi.  (( 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
....peline
          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 "||">]
    )
  ]
)
(command.Redirect
  child:(C (w <Lit_Chars cat>))
  redirects:[
    (Redir
      op:<Redir_DLess "<<">
      loc:(redir_loc.Fd fd:0)
      arg:(redir_param.HereDoc
        here_begin:(w <Lit_Chars EOF>)
        here_end_tok:<Undefined_Tok "EOF\n">
        stdin_parts:[
          <Lit_Chars "1 ">
          (CommandSub
            left_token:<Left_DollarParen "$(">
            child:(command.CommandList
              children:[
                (C (w <Lit_Chars echo>) (w <Lit_Chars 2>))
                (C (w <Lit_Chars echo>) (w <Lit_Chars 3>))
              ]
            )
            right:<Eof_RParen ")">
          )
          <Lit_Chars " 4\n">
        ]
      )
    )
  ]
)
(command.AndOr
  children:[
    (command.Redirect
      child:(C (w <Lit_Chars cat>))
      redirects:[
        (Redir
          op:<Redir_DLess "<<">
          loc:(redir_loc.Fd fd:0)
          arg:(redir_param.HereDoc
            here_begin:(w <Lit_Chars EOF>)
            here_end_tok:<Undefined_Tok "EOF\n">
            stdin_parts:[<Lit_Chars "PIPE 1\n"> <Lit_Chars "PIPE 2\n">]
          )
        )
      ]
    )
    (C (w <Lit_Chars echo>) (w <Lit_Chars hi>))
  ]
  ops:[<Op_DPipe "||">]
)
(command.AndOr
  children:[
    (command.Redirect
      child:(C (w <Lit_Chars cat>))
      redirects:[
        (Redir
          op:<Redir_DLess "<<">
          loc:(redir_loc.Fd fd:0)
          arg:(redir_param.HereDoc
            here_begin:(w <Lit_Chars EOF>)
            here_end_tok:<Undefined_Tok "EOF\n">
            stdin_parts:[<Lit_Chars "PIPE 1\n"> <Lit_Chars "PIPE 2\n">]
          )
        )
      ]
    )
    (C (w <Lit_Chars echo>) (w <Lit_Chars hi>))
  ]
  ops:[<Op_DAmp "&&">]
)
(command.AndOr
  children:[
    (command.Redirect
      child:(C (w <Lit_Chars tac>))
      redirects:[
        (Redir
          op:<Redir_DLess "<<">
          loc:(redir_loc.Fd fd:0)
          arg:(redir_param.HereDoc
            here_begin:(w <Lit_Chars EOF1>)
            here_end_tok:<Undefined_Tok "EOF1\n">
            stdin_parts:[<Lit_Chars "PIPE A1\n"> <Lit_Chars "PIPE A2\n">]
          )
        )
      ]
    )
    (command.Redirect
      child:(C (w <Lit_Chars tac>))
      redirects:[
        (Redir
          op:<Redir_DLess "<<">
          loc:(redir_loc.Fd fd:0)
          arg:(redir_param.HereDoc
            here_begin:(w <Lit_Chars EOF2>)
            here_end_tok:<Undefined_Tok "EOF2\n">
            stdin_parts:[<Lit_Chars "PIPE B1\n"> <Lit_Chars "PIPE B2\n">]
          )
        )
      ]
    )
  ]
  ops:[<Op_DAmp "&&">]
)
(command.Pipeline
  children:[
    (command.Redirect
      child:(C (w <Lit_Chars cat>))
      redirects:[
        (Redir
          op:<Redir_DLess "<<">
          loc:(redir_loc.Fd fd:0)
          arg:(redir_param.HereDoc
            here_begin:(w <Lit_Chars EOF>)
            here_end_tok:<Undefined_Tok "EOF\n">
            stdin_parts:[<Lit_Chars "PIPE 1\n"> <Lit_Chars "PIPE 2\n">]
          )
        )
      ]
    )
    (C (w <Lit_Chars tac>))
  ]
  ops:[<Op_Pipe "|">]
)
(command.Pipeline
  children:[
    (command.Redirect
      child:(C (w <Lit_Chars cat>))
      redirects:[
        (Redir
          op:<Redir_DLess "<<">
          loc:(redir_loc.Fd fd:0)
          arg:(redir_param.HereDoc
            here_begin:(w <Lit_Chars EOF>)
            here_end_tok:<Undefined_Tok "EOF\n">
            stdin_parts:[<Lit_Chars "PIPE 1\n"> <Lit_Chars "PIPE 2\n">]
          )
        )
      ]
    )
    (C (w <Lit_Chars tac>))
  ]
  ops:[<Op_Pipe "|">]
)
(command.CommandList
  children:[
    (command.Sentence
      child:(command.Redirect
        child:(C (w <Lit_Chars cat>))
        redirects:[
          (Redir
            op:<Redir_DLess "<<">
            loc:(redir_loc.Fd fd:0)
            arg:(redir_param.HereDoc
              here_begin:(w <Lit_Chars EOF>)
      ......        here_end_tok:<Undefined_Tok "EOF\n">
              stdin_parts:[<Lit_Chars "PIPE 1\n"> <Lit_Chars "PIPE 2\n">]
            )
          )
        ]
      )
      terminator:<Op_Semi ";">
    )
    (C (w <Lit_Chars echo>) (w <Lit_Chars hi>))
  ]
)
(command.CommandList
  children:[
    (command.Sentence
      child:(command.Redirect
        child:(C (w <Lit_Chars cat>))
        redirects:[
          (Redir
            op:<Redir_DLess "<<">
            loc:(redir_loc.Fd fd:0)
            arg:(redir_param.HereDoc
              here_begin:(w <Lit_Chars EOF>)
              here_end_tok:<Undefined_Tok "EOF\n">
              stdin_parts:[<Lit_Chars "PIPE 1\n"> <Lit_Chars "PIPE 2\n">]
            )
          )
        ]
      )
      terminator:<Op_Semi ";">
    )
    (C (w <Lit_Chars echo>) (w <Lit_Chars hi>))
  ]
)
(command.Redirect
  child:(C (w <Lit_Chars cat>))
  redirects:[
    (Redir
      op:<Redir_DLessDash "<<-">
      loc:(redir_loc.Fd fd:0)
      arg:(redir_param.HereDoc
        here_begin:(w <Lit_Chars EOF>)
        here_end_tok:<Undefined_Tok "EOF\n">
        stdin_parts:[<Lit_Chars "one tab then foo: "> ($ foo) <Lit_Chars "\n">]
      )
    )
  ]
)
(command.Redirect
  child:(C (w <Lit_Chars cat>))
  redirects:[
    (Redir
      op:<Redir_DLess "<<">
      loc:(redir_loc.Fd fd:0)
      arg:(redir_param.HereDoc
        here_begin:(w (DQ <Lit_Chars EOF>))
        here_end_tok:<Undefined_Tok "EOF\n">
        stdin_parts:[<Lit_Chars "$v\n"> <Lit_Chars "\"two\n">]
      )
    )
  ]
)
(command.Redirect
  child:(C (w <Lit_Chars cat>))
  redirects:[
    (Redir
      op:<Redir_DLess "<<">
      loc:(redir_loc.Fd fd:0)
      arg:(redir_param.HereDoc
        here_begin:(w (SQ EOF))
        here_end_tok:<Undefined_Tok "EOF\n">
        stdin_parts:[<Lit_Chars "single-quoted: $var\n">]
      )
    )
  ]
)
(command.Redirect
  child:(C (w <Lit_Chars cat>))
  redirects:[
    (Redir
      op:<Redir_DLess "<<">
      loc:(redir_loc.Fd fd:0)
      arg:(redir_param.HereDoc
        here_begin:(w
          <Lit_Chars EO>
          (word_part.EscapedLiteral token:<Lit_EscapedChar "\\F"> ch:F)
        )
        here_end_tok:<Undefined_Tok "EOF\n">
        stdin_parts:[<Lit_Chars "single-quoted: $var\n">]
      )
    )
  ]
)
(command.CommandList
  children:[
    (command.Pipeline
      children:[
        (command.Redirect
          child:(C (w <Lit_Chars cat>))
          redirects:[
            (Redir
              op:<Redir_DLess "<<">
              loc:(redir_loc.Fd fd:0)
              arg:(redir_param.HereDoc
                here_begin:(w <Lit_Chars EOF1>)
                here_end_tok:<Undefined_Tok "EOF1\n">
                stdin_parts:[<Lit_Chars "PIPE A1\n"> <Lit_Chars "PIPE A2\n">]
              )
            )
          ]
        )
        (command.Redirect
          child:(C (w <Lit_Chars tac>))
          redirects:[
            (Redir
              op:<Redir_DLess "<<">
              loc:(redir_loc.Fd fd:0)
              arg:(redir_param.HereDoc
                here_begin:(w <Lit_Chars EOF2>)
                here_end_tok:<Undefined_Tok "EOF2\n">
                stdin_parts:[<Lit_Chars "PIPE B1\n"> <Lit_Chars "PIPE B2\n">]
              )
            )
          ]
        )
      ]
      ops:[<Op_Pipe "|">]
    )
  ]
)
(command.Redirect
  child:(C (w <Lit_Chars cat>))
  redirects:[
    (Redir
      op:<Redir_DLess "<<">
      loc:(redir_loc.Fd fd:0)
      arg:(redir_param.HereDoc
        here_begin:(w <Lit_Chars EOF>)
        here_end_tok:<Undefined_Tok "EOF\n">
        stdin_parts:[
          ($ v)
          <Lit_Chars "\n">
          <Right_DoubleQuote "\"">
          <Lit_Chars "two\n">
        ]
      )
    )
  ]
)
(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:...0x7f3a1a51da10
                lhs:(sh_lhs.Name left:...0x7f3a1a51da10 name:array)
                op:assign_op.Equal
                rhs:(w
                  (ShArrayLiteral
                    left:<Op_LParen "(">
                    words:[
                      (w <Lit_Chars a>) (w <Lit_Chars b>) (w <Lit_Chars c>)
                    ]
                    right:<Right_ShArrayLiteral ")">
                  )
                )
              )
            ]
          )
          right:<Eof_RParen ")">
        )
      )
    )
  ]
)
(command.CommandList
  children:[
    (command.Subshell
      left:<Op_LParen "(">
      child:(command.ShAssignment
        left:<Lit_VarLike "array=">
        pairs:[
          (AssignPair
            left:...0x7f3a1a51d7a0
            lhs:(sh_lhs.Name left:...0x7f3a1a51d7a0 name:array)
            op:assign_op.Equal
            rhs:(w
              (ShArrayLiteral
                left:<Op_LParen "(">
                words:[(w <Lit_Chars a>) (w <Lit_Chars b>) (w <Lit_Chars c>)]
                right:<Right_ShArrayLiteral ")">
              )
            )
          )
        ]
      )
      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:[
    (comma...nd.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
  child...ren:[
    (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_Chars 1>))
          ]
        )
        right:<Right_Subshell ")">
        is_last_cmd:F
      )
      terminator:<Op_Semi ";">
    )
    (C (w <Lit_Chars echo>) (w <Lit_Chars PWD>) (w <Lit_Chars 2>))
  ]
)
(command.CommandList
  children:[
    (C
      (w <Lit_Chars echo>)
      (w
        (CommandSub
          left_token:<Left_DollarParen "$(">
          child:(command.CommandList
            children:[
              (command.Sentence
                child:(command.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 "}">
                  )
                )
                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:(command.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 "}">
              )
            )
            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.......  errcmd=( "${SETUP_STATE[$err.cmd]}" )
                              ^
"<cmd_parse_test>":1: Unexpected token while parsing arithmetic: '.'
..>))
  ]
)
(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
  (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:...0x7f3a1a4637a0
          lhs:(sh_lhs.Name left:...0x7f3a1a4637a0 name:errcmd)
          op:assign_op.Equal
          rhs:(w
            (ShArrayLiteral
              left:<Op_LParen "(">
              words:[
                (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_ShArrayLiteral ")">
            )
          )
        )
      ]
    )
  ]
)
(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:...0x7f3a1a468600
          lhs:(sh_lhs.Name left:...0x7f3a1a468600 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:...0x7f3a1a463d50
          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:...0x7f3a1a4630b8
        )
      ]
      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:...0x7f3a1a463188
          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:...0x7f3a1a468600
        )
      ]
      else_action:[]
      fi_kw:<KW_Fi fi>
    )
  ]
)
(command.CommandList
  children:[
    (command.If
      if_kw:<KW_If if>
      arms:[
        (IfArm
          keyword:...0x7f3a1a468050
          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:...0x7f3a1a515ef0
                  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:...0x7f3a1a515940
                )
              ]
              else_action:[]
              fi_kw:<KW_Fi fi>
            )
          ]
          then_tok:...0x7f3a1a515d50
        )
      ]
      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:(c...ommand.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_Chars 3>
      pattern:(pat.Words
        words:[
          (w <Lit_Chars 3> <Lit_Comma ","> <Lit_Pound "#"> <Lit_Star "*">)
          (w <Lit_Chars 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:...0x7f3a1a515870
                  lhs:(sh_lhs.Name left:...0x7f3a1a515870 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 "'">
        )
      )
    )
  ]
)
(command.Redirect
  child:(C (w <Lit_Chars echo>) (w <Lit_Chars hi>))
  redirects:[
    (Redir
      op:<Redir_Clobber ">|">
      loc:(redir_loc.Fd fd:1)
      arg:(w <Lit_Chars clobbered.txt>)
    )
  ]
)
(Redir op:<Redir_GreatAnd "1>&"> loc:(redir_loc.Fd fd:1) arg:(w <Lit_Chars 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:[])
)
(command.Redirect
  child:(C (w <Lit_Chars cat>))
  redirects:[
    (Redir
      op:<Redir_DLess "<<">
      loc:(redir_loc.Fd fd:0)
      arg:(redir_param.HereDoc
        here_begin:(w <Lit_Chars EOF>)
        here_end_tok:<Undefined_Tok "EOF\n">
        stdin_parts:[<Lit_Chars "hi\n">]
      )
    )
    (Redir
      op:<Redir_Great ">">
      loc:(redir_loc.Fd fd:1)
      arg:(w <Lit_Chars out.txt>)
    )
  ]
)
(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:[])
)
(command.Redirect
  child:(C (w <Lit_Chars cat>))
  redirects:[
    (Redir
      op:<Redir_Great ">">
      loc:(redir_loc.Fd fd:1)
      arg:(w <Lit_Chars out.txt>)
    )
    (Redir
      op:<Redir_GreatAnd "1>&">
      loc:(redir_loc.Fd fd:1)
      arg:(w <Lit_Chars 2>)
    )
  ]
)
(command.Redirect
  child:(C (w <Lit_Chars cat>))
  redirects:[
    (Redir
      op:<Redir_LessAnd "<&">
      loc:(redir_loc.Fd fd:0)
      arg:(w <Lit_Chars 3>)
    )
  ]
)
(command.CommandList
  children:[
    (command.ShAssignment
      left:<Lit_VarLike "ONE=">
      pairs:[
        (AssignPair
          left:...0x7f3a1a5159a8
          lhs:(sh_lhs.Name left:...0x7f3a1a5159a8 name:ONE)
          op:assign_op.Equal
          rhs:(w <Lit_Chars 1>)
        )
        (AssignPair
          left:<Lit_VarLike "TWO=">
          lhs:(sh_lhs.Name left:...0x7f3a1a5158d8 name:TWO)
          op:assign_op.Equal
          rhs:(w <Lit_Chars 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.Redirect
      child:(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:[
    (command.Redirect
      child:(C
        (w <Lit_Chars echo>)
        (w <Lit_Chars 1>)
        (w <Lit_Chars 2>)
        (w <Lit_Chars 3>)
      )
      redirects:[
        (Redir
          op:<Redir_Great ">">
          loc:(redir_loc.Fd fd:1)
          arg:(w <Lit_Chars out.txt>)
        )
      ]
    )
  ]
)
(C (w <Lit_Chars ls>) (w <Lit_Chars foo>))
(command.Simple
  blame_tok:<Lit_Chars ls>
  more_env:[
    (EnvPair left:<Lit_VarLike "FOO="> n.
----------------------------------------------------------------------
Ran 83 tests in 0.382s

OK
ame:FOO val:(w <Lit_Chars bar>))
  ]
  words:[(w <Lit_Chars ls>) (w <Lit_Chars foo>)]
  is_last_cmd:F
)
(command.Redirect
  child:(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.Redirect
  child:(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>)
    )
  ]
)