#!/usr/bin/env bash
#
# Usage:
#   ./spec-file.sh <function name>

set -o nounset
set -o pipefail
set -o errexitsetconst global FOO = "bar"

readonly DASH = $[which dash !2 >/dev/null || echo /bin/sh]setconst global FOO = "bar"
readonly BASH = $[which bash]setconst global FOO = "bar"
readonly MKSH = $[which mksh]setconst global FOO = "bar"
readonly ZSH = $[which zsh]setconst global FOO = "bar"
readonly BUSYBOX_ASH = '_tmp/shells/ash'

if test -f _bin/osh {setconst global FOO = "bar"
  # TODO: Does it make sense to copy the binary to an unrelated to directory,
  # like /tmp?  /tmp/{oil.ovm,osh}.
  readonly OSH_BIN = '_bin/osh'setconst global FOO = "bar"

  # HACK that relies on word splitting.  TODO: Use ${OSH[@]} everywhere
  readonly OSH = ""bin/osh $OSH_BIN""
} else {setconst global FOO = "bar"
  readonly OSH = '"bin/osh'"
}setconst global FOO = "bar"


# ash and dash are similar, so not including ash by default.  zsh is not quite
# POSIX.
readonly REF_SHELLS = '('$DASH $BASH $MKSH)

#
# Setup
#

# dash and bash should be there by default on Ubuntu.
proc install-shells {
  sudo apt-get install busybox-static mksh zsh
  mkdir -p _tmp/shells
  ln -s -f --verbose $[which busybox] $BUSYBOX_ASH
}

# TODO: Maybe do this before running all tests.
proc check-shells {
  for sh in [$(REF_SHELLS[@]) $ZSH $OSH] {
    test -e $sh || do { echo "ERROR: $sh does not exist"; break; }
    test -x $sh || do { echo "ERROR: $sh isn't executable"; break; }
  }
}

proc _wget {
  wget --no-clobber --directory _tmp/src @Argv
}

# As of March 2017
proc download-shell-source {
  mkdir -p _tmp/src

  # https://tiswww.case.edu/php/chet/bash/bashtop.html - 9/2016 release
  # https://ftp.gnu.org/gnu/bash/
  _wget https://ftp.gnu.org/gnu/bash/bash-4.4.tar.gz

  # https://www.mirbsd.org/mksh.htm - no dates given
  _wget https://www.mirbsd.org/MirOS/dist/mir/mksh/mksh-R54.tgz

  # https://tracker.debian.org/pkg/dash  -- old versions
  # http://www.linuxfromscratch.org/blfs/view/svn/postlfs/dash.html
  # Site seems down now.
  # _wget http://gondor.apana.org.au/~herbert/dash/files/dash-0.5.9.1.tar.gz

  # http://zsh.sourceforge.net/News/ - 12/2016 release
  _wget https://downloads.sourceforge.net/project/zsh/zsh/5.3.1/zsh-5.3.1.tar.xz
}

proc maybe-show {
  var path = $1
  if test -e $path {
    echo "--- $path ---"
    cat $path
    echo
  }
}

proc version-text {
  date
  echo

  var branch = $[git rev-parse --abbrev-ref HEAD]
  var hash = $[git rev-parse $branch]
  echo "oil version: $hash on branch $branch"
  echo

  python3 --version !2 > !1
  echo

  $BASH --version | head -n 1
  echo

  $ZSH --version | head -n 1
  echo

  # These don't have versions
  dpkg -s dash | egrep '^Package|Version'
  echo

  dpkg -s mksh | egrep '^Package|Version'
  echo

  # Need || true because of pipefail
  do { busybox || true; } | head -n 1
  echo

  maybe-show /etc/debian_version
  maybe-show /etc/lsb-release
}

#
# Helpers
#

proc sh-spec {
  var this_dir = $[cd $[dirname $0] && pwd]

  var tmp_env = "$this_dir/../_tmp/spec-tmp"
  mkdir -p $tmp_env

  test/sh_spec.py \
      --tmp-env $tmp_env \
      --path-env "$this_dir/../spec/bin:$PATH" \
      @Argv
}

#
# Misc
#

# Really what I want is enter(func) and exit(func), and filter by regex?
proc trace-var-sub {
  var out = '_tmp/coverage'
  mkdir -p $out

  # This creates *.cover files, with line counts.
  #python -m trace --count -C $out \

  # This prints trace with line numbers to stdout.
  #python -m trace --trace -C $out \
  python -m trace --trackcalls -C $out \
    test/sh_spec.py spec/var-sub.test.sh $DASH $BASH @Argv

  ls -l $out
  head $out/*.cover
}

#
# Run All tests
#

proc all {
  test/spec-runner.sh all-parallel @Argv
}


#
# Invidual tests.
#
# We configure the shells they run on and the number of allowed failures (to
# prevent regressions.)
#

proc smoke {
  sh-spec spec/smoke.test.sh $(REF_SHELLS[@]) $OSH @Argv
}

proc osh-only {
  sh-spec spec/osh-only.test.sh $OSH @Argv
}

# Regress bugs
proc bugs {
  sh-spec spec/bugs.test.sh $(REF_SHELLS[@]) $OSH @Argv
}

proc blog1 {
  sh-spec spec/blog1.test.sh \
    $(REF_SHELLS[@]) $ZSH $OSH @Argv
}

proc blog2 {
  sh-spec spec/blog2.test.sh \
    $(REF_SHELLS[@]) $ZSH $OSH @Argv
}

proc blog-other1 {
  sh-spec spec/blog-other1.test.sh \
    $(REF_SHELLS[@]) $ZSH $OSH @Argv
}

proc comments {
  sh-spec spec/comments.test.sh $(REF_SHELLS[@]) $OSH @Argv
}

proc word-split {
  sh-spec spec/word-split.test.sh --osh-failures-allowed 3 \
    $(REF_SHELLS[@]) $OSH @Argv
}

proc word-eval {
  sh-spec spec/word-eval.test.sh \
    $(REF_SHELLS[@]) $OSH @Argv
}

# 'do' -- detected statically as syntax error?  hm.
proc assign {
  sh-spec spec/assign.test.sh --osh-failures-allowed 3 \
    $(REF_SHELLS[@]) $OSH @Argv 
}

proc background {
  sh-spec spec/background.test.sh \
    $(REF_SHELLS[@]) $OSH @Argv 
}

proc subshell {
  sh-spec spec/subshell.test.sh \
    $(REF_SHELLS[@]) $OSH @Argv 
}

# Need to fix $ tokens, and $''
proc quote {
  sh-spec spec/quote.test.sh --osh-failures-allowed 4 \
    $(REF_SHELLS[@]) $OSH @Argv
}

proc loop {
  sh-spec spec/loop.test.sh \
    $(REF_SHELLS[@]) $OSH @Argv
}

# Not implemented in osh at all.  Need glob matching of words.
proc case_ {
  sh-spec spec/case_.test.sh --osh-failures-allowed 2 \
    $(REF_SHELLS[@]) $OSH @Argv
}

proc if_ {
  sh-spec spec/if_.test.sh --osh-failures-allowed 1 \
    $(REF_SHELLS[@]) $ZSH $OSH @Argv
}

proc builtins {
  sh-spec spec/builtins.test.sh --osh-failures-allowed 3 \
    $(REF_SHELLS[@]) $OSH @Argv
}

proc builtin-vars {
  sh-spec spec/builtin-vars.test.sh --osh-failures-allowed 2 \
    $(REF_SHELLS[@]) $OSH @Argv
}

proc builtin-getopts {
  sh-spec spec/builtin-getopts.test.sh --osh-failures-allowed 1 \
    $(REF_SHELLS[@]) $BUSYBOX_ASH $OSH @Argv
}

proc builtin-test {
  sh-spec spec/builtin-test.test.sh --osh-failures-allowed 1 \
    $(REF_SHELLS[@]) $OSH @Argv
}

# Bash impleement type -t, but no other shell does.  For Nix.
proc builtin-type {
  sh-spec spec/builtin-type.test.sh \
    $BASH $OSH @Argv
}

proc builtins-special {
  sh-spec spec/builtins-special.test.sh --osh-failures-allowed 3 \
    $(REF_SHELLS[@]) $OSH @Argv
}

proc command-parsing {
  sh-spec spec/command-parsing.test.sh $(REF_SHELLS[@]) $OSH @Argv
}

proc func-parsing {
  sh-spec spec/func-parsing.test.sh $(REF_SHELLS[@]) $OSH @Argv
}

proc func {
  sh-spec spec/func.test.sh \
    $(REF_SHELLS[@]) $OSH @Argv
}

proc glob {
  sh-spec spec/glob.test.sh --osh-failures-allowed 2 \
    $(REF_SHELLS[@]) $BUSYBOX_ASH $OSH @Argv
}

proc arith {
  sh-spec spec/arith.test.sh --osh-failures-allowed 3 \
    $(REF_SHELLS[@]) $ZSH $OSH @Argv
}

proc command-sub {
  sh-spec spec/command-sub.test.sh --osh-failures-allowed 2 \
    $(REF_SHELLS[@]) $OSH @Argv
}

proc command_ {
  sh-spec spec/command_.test.sh --osh-failures-allowed 1 \
    $(REF_SHELLS[@]) $OSH @Argv
}

proc pipeline {
  sh-spec spec/pipeline.test.sh --osh-failures-allowed 3 \
    $(REF_SHELLS[@]) $ZSH $OSH @Argv
}

proc explore-parsing {
  sh-spec spec/explore-parsing.test.sh \
    $(REF_SHELLS[@]) $OSH @Argv
}

proc parse-errors {
  sh-spec spec/parse-errors.test.sh --osh-failures-allowed 4 \
    $(REF_SHELLS[@]) $OSH @Argv
}

proc here-doc {
  # NOTE: The last two tests, 28 and 29, have different behavior on my Ubuntu
  # and Debian machines.
  # - On Ubuntu, read_from_fd.py fails with Errno 9 -- bad file descriptor.
  # - On Debian, the whole process hangs.
  # Is this due to Python 3.2 vs 3.4?  Either way osh doesn't implement the
  # functionality, so it's probably best to just implement it.
  sh-spec spec/here-doc.test.sh --osh-failures-allowed 2 --range 0-27 \
    $(REF_SHELLS[@]) $OSH @Argv
}

proc redirect {
  sh-spec spec/redirect.test.sh --osh-failures-allowed 8 \
    $(REF_SHELLS[@]) $OSH @Argv
}

proc posix {
  sh-spec spec/posix.test.sh \
    $(REF_SHELLS[@]) $OSH @Argv
}

proc special-vars {
  sh-spec spec/special-vars.test.sh --osh-failures-allowed 4 \
    $(REF_SHELLS[@]) $OSH @Argv
}

# dash/mksh don't implement this.
proc introspect {
  sh-spec spec/introspect.test.sh \
    $BASH $OSH @Argv
}

# DONE -- pysh is the most conformant!
proc tilde {
  sh-spec spec/tilde.test.sh $(REF_SHELLS[@]) $OSH @Argv
}

proc var-op-test {
  sh-spec spec/var-op-test.test.sh --osh-failures-allowed 5 \
    $(REF_SHELLS[@]) $OSH @Argv
}

proc var-op-other {
  sh-spec spec/var-op-other.test.sh --osh-failures-allowed 5 \
    $(REF_SHELLS[@]) $OSH @Argv
}

proc var-op-strip {
  sh-spec spec/var-op-strip.test.sh --osh-failures-allowed 2 \
    $(REF_SHELLS[@]) $ZSH $OSH @Argv
}

proc var-sub {
  # NOTE: ZSH has interesting behavior, like echo hi > "$@" can write to TWO
  # FILES!  But ultimately we don't really care, so I disabled it.
  sh-spec spec/var-sub.test.sh \
    $(REF_SHELLS[@]) $OSH @Argv
}

proc var-num {
  sh-spec spec/var-num.test.sh \
    $(REF_SHELLS[@]) $OSH @Argv
}

proc var-sub-quote {
  sh-spec spec/var-sub-quote.test.sh \
    $(REF_SHELLS[@]) $OSH @Argv
}

proc sh-options {
  sh-spec spec/sh-options.test.sh --osh-failures-allowed 2 \
    $(REF_SHELLS[@]) $OSH @Argv
}

proc errexit {
  sh-spec spec/errexit.test.sh \
    $(REF_SHELLS[@]) $BUSYBOX_ASH $OSH @Argv
}

# 
# Non-POSIX extensions: arrays, brace expansion, [[, ((, etc.
#

# There as many non-POSIX arithmetic contexts.
proc arith-context {
  sh-spec spec/arith-context.test.sh --osh-failures-allowed 7 \
    $BASH $MKSH $ZSH $OSH @Argv
}

proc array {
  sh-spec spec/array.test.sh --osh-failures-allowed 12 \
    $BASH $MKSH $OSH @Argv
}

proc array-compat {
  sh-spec spec/array-compat.test.sh --osh-failures-allowed 7 \
    $BASH $MKSH $OSH @Argv
}

proc type-compat {
  sh-spec spec/type-compat.test.sh $BASH @Argv
}

# += is not POSIX and not in dash.
proc append {
  sh-spec spec/append.test.sh --osh-failures-allowed 4 \
    $BASH $MKSH $OSH @Argv 
}

# associative array -- mksh implements different associative arrays.
proc assoc {
  sh-spec spec/assoc.test.sh $BASH @Argv
}

# ZSH also has associative arrays, which means we probably need them
proc assoc-zsh {
  sh-spec spec/assoc-zsh.test.sh $ZSH @Argv
}

# NOTE: zsh passes about half and fails about half.  It supports a subset of [[
# I guess.
proc dbracket {
  sh-spec spec/dbracket.test.sh --osh-failures-allowed 5 \
    $BASH $MKSH $OSH @Argv
  #sh-spec spec/dbracket.test.sh $BASH $MKSH $OSH $ZSH "$@"
}

proc dparen {
  sh-spec spec/dparen.test.sh \
    $BASH $MKSH $ZSH $OSH @Argv
}

proc brace-expansion {
  # TODO for osh: implement num ranges, mark char ranges unimplemented?
  sh-spec spec/brace-expansion.test.sh --osh-failures-allowed 12 \
    $BASH $MKSH $ZSH $OSH @Argv
}

proc regex {
  sh-spec spec/regex.test.sh --osh-failures-allowed 2 \
    $BASH $ZSH $OSH @Argv
}

proc process-sub {
  # mksh and dash don't support it
  sh-spec spec/process-sub.test.sh --osh-failures-allowed 2 \
    $BASH $ZSH $OSH @Argv
}

proc extended-glob {
  # Do NOT use dash here.  Brace sub breaks things.
  sh-spec spec/extended-glob.test.sh $BASH $MKSH @Argv
}

# ${!var} syntax -- oil should replace this with associative arrays.
proc var-ref {
  sh-spec spec/var-ref.test.sh --osh-failures-allowed 5 \
    $BASH $MKSH $OSH @Argv
}

proc let {
  sh-spec spec/let.test.sh $BASH $MKSH $ZSH @Argv
}

proc for-expr {
  sh-spec spec/for-expr.test.sh --osh-failures-allowed 2 \
    $MKSH $BASH $OSH @Argv
}

# TODO: This is for the ANTLR grammars, in the oil-sketch repo.
# osh has infinite loop?
proc shell-grammar {
  sh-spec spec/shell-grammar.test.sh $BASH $MKSH $ZSH @Argv
}

@Argv
(CommandList
  children: [
    (C {(set)} {(-o)} {(nounset)})
    (C {(set)} {(-o)} {(pipefail)})
    (C {(set)} {(-o)} {(errexit)})
    (Assignment
      keyword: Assign_Readonly
      pairs: [
        (assign_pair
          lhs: (LhsName name:DASH)
          op: Equal
          rhs: 
            {
              (CommandSubPart
                command_list: 
                  (CommandList
                    children: [
                      (AndOr
                        children: [
                          (SimpleCommand
                            words: [{(which)} {(dash)}]
                            redirects: [
                              (Redir
                                op_id: Redir_Great
                                fd: 2
                                arg_word: {(/dev/null)}
                                spids: [40]
                              )
                            ]
                          )
                          (C {(echo)} {(/bin/sh)})
                        ]
                        op_id: Op_DPipe
                      )
                    ]
                  )
                left_token: <Left_CommandSub "$(">
                spids: [35 48]
              )
            }
          spids: [34]
        )
      ]
      spids: [32]
    )
    (Assignment
      keyword: Assign_Readonly
      pairs: [
        (assign_pair
          lhs: (LhsName name:BASH)
          op: Equal
          rhs: 
            {
              (CommandSubPart
                command_list: (CommandList children:[(C {(which)} {(bash)})])
                left_token: <Left_CommandSub "$(">
                spids: [53 57]
              )
            }
          spids: [52]
        )
      ]
      spids: [50]
    )
    (Assignment
      keyword: Assign_Readonly
      pairs: [
        (assign_pair
          lhs: (LhsName name:MKSH)
          op: Equal
          rhs: 
            {
              (CommandSubPart
                command_list: (CommandList children:[(C {(which)} {(mksh)})])
                left_token: <Left_CommandSub "$(">
                spids: [62 66]
              )
            }
          spids: [61]
        )
      ]
      spids: [59]
    )
    (Assignment
      keyword: Assign_Readonly
      pairs: [
        (assign_pair
          lhs: (LhsName name:ZSH)
          op: Equal
          rhs: 
            {
              (CommandSubPart
                command_list: (CommandList children:[(C {(which)} {(zsh)})])
                left_token: <Left_CommandSub "$(">
                spids: [71 75]
              )
            }
          spids: [70]
        )
      ]
      spids: [68]
    )
    (Assignment
      keyword: Assign_Readonly
      pairs: [
        (assign_pair
          lhs: (LhsName name:BUSYBOX_ASH)
          op: Equal
          rhs: {(_tmp/shells/ash)}
          spids: [79]
        )
      ]
      spids: [77]
    )
    (If
      arms: [
        (if_arm
          cond: [(Sentence child:(C {(test)} {(-f)} {(_bin/osh)}) terminator:<Op_Semi ";">)]
          action: [
            (Assignment
              keyword: Assign_Readonly
              pairs: [(assign_pair lhs:(LhsName name:OSH_BIN) op:Equal rhs:{(_bin/osh)} spids:[105])]
              spids: [103]
            )
            (Assignment
              keyword: Assign_Readonly
              pairs: [
                (assign_pair
                  lhs: (LhsName name:OSH)
                  op: Equal
                  rhs: {(DQ ("bin/osh ") ($ VSub_Name "$OSH_BIN"))}
                  spids: [116]
                )
              ]
              spids: [114]
            )
          ]
          spids: [-1 92]
        )
      ]
      else_action: [
        (Assignment
          keyword: Assign_Readonly
          pairs: [(assign_pair lhs:(LhsName name:OSH) op:Equal rhs:{(DQ (bin/osh))} spids:[127])]
          spids: [125]
        )
      ]
      spids: [122 132]
    )
    (Assignment
      keyword: Assign_Readonly
      pairs: [
        (assign_pair
          lhs: (LhsName name:REF_SHELLS)
          op: Equal
          rhs: 
            {
              (ArrayLiteralPart
                words: [{($ VSub_Name "$DASH")} {($ VSub_Name "$BASH")} {($ VSub_Name "$MKSH")}]
              )
            }
          spids: [144]
        )
      ]
      spids: [142]
    )
    (FuncDef
      name: install-shells
      body: 
        (BraceGroup
          children: [
            (C {(sudo)} {(apt-get)} {(install)} {(busybox-static)} {(mksh)} {(zsh)})
            (C {(mkdir)} {(-p)} {(_tmp/shells)})
            (C {(ln)} {(-s)} {(-f)} {(--verbose)} 
              {
                (DQ 
                  (CommandSubPart
                    command_list: (CommandList children:[(C {(which)} {(busybox)})])
                    left_token: <Left_CommandSub "$(">
                    spids: [203 207]
                  )
                )
              } {($ VSub_Name "$BUSYBOX_ASH")}
            )
          ]
          spids: [171]
        )
      spids: [167 170]
    )
    (FuncDef
      name: check-shells
      body: 
        (BraceGroup
          children: [
            (ForEach
              iter_name: sh
              iter_words: [
                {
                  (DQ 
                    (BracedVarSub
                      token: <VSub_Name REF_SHELLS>
                      bracket_op: (WholeArray op_id:Lit_At)
                      spids: [232 237]
                    )
                  )
                }
                {($ VSub_Name "$ZSH")}
                {($ VSub_Name "$OSH")}
              ]
              do_arg_iter: False
              body: 
                (DoGroup
                  children: [
                    (AndOr
                      children: [
                        (C {(test)} {(-e)} {($ VSub_Name "$sh")})
                        (BraceGroup
                          children: [
                            (Sentence
                              child: 
                                (C {(echo)} {(DQ ("ERROR: ") ($ VSub_Name "$sh") (" does not exist"))})
                              terminator: <Op_Semi ";">
                            )
                            (Sentence
                              child: (ControlFlow token:<ControlFlow_Break break>)
                              terminator: <Op_Semi ";">
                            )
                          ]
                          spids: [256]
                        )
                      ]
                      op_id: Op_DPipe
                    )
                    (AndOr
                      children: [
                        (C {(test)} {(-x)} {($ VSub_Name "$sh")})
                        (BraceGroup
                          children: [
                            (Sentence
                              child: 
                                (C {(echo)} {(DQ ("ERROR: ") ($ VSub_Name "$sh") (" isn't executable"))})
                              terminator: <Op_Semi ";">
                            )
                            (Sentence
                              child: (ControlFlow token:<ControlFlow_Break break>)
                              terminator: <Op_Semi ";">
                            )
                          ]
                          spids: [281]
                        )
                      ]
                      op_id: Op_DPipe
                    )
                  ]
                  spids: [245 298]
                )
              spids: [230 243]
            )
          ]
          spids: [222]
        )
      spids: [218 221]
    )
    (FuncDef
      name: _wget
      body: 
        (BraceGroup
          children: [(C {(wget)} {(--no-clobber)} {(--directory)} {(_tmp/src)} {(DQ ($ VSub_At "$@"))})]
          spids: [307]
        )
      spids: [303 306]
    )
    (FuncDef
      name: download-shell-source
      body: 
        (BraceGroup
          children: [
            (C {(mkdir)} {(-p)} {(_tmp/src)})
            (C {(_wget)} {(https) (Lit_Other ":") (//ftp.gnu.org/gnu/bash/bash-4.4.tar.gz)})
            (C {(_wget)} {(https) (Lit_Other ":") (//www.mirbsd.org/MirOS/dist/mir/mksh/mksh-R54.tgz)})
            (C {(_wget)} 
              {(https) (Lit_Other ":") 
                (//downloads.sourceforge.net/project/zsh/zsh/5.3.1/zsh-5.3.1.tar.xz)
              }
            )
          ]
          spids: [332]
        )
      spids: [328 331]
    )
    (FuncDef
      name: maybe-show
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:path)
                  op: Equal
                  rhs: {($ VSub_Number "$1")}
                  spids: [410]
                )
              ]
              spids: [408]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: (C {(test)} {(-e)} {($ VSub_Name "$path")})
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (C {(echo)} {(DQ ("--- ") ($ VSub_Name "$path") (" ---"))})
                    (C {(cat)} {($ VSub_Name "$path")})
                    (C {(echo)})
                  ]
                  spids: [-1 423]
                )
              ]
              spids: [-1 443]
            )
          ]
          spids: [405]
        )
      spids: [401 404]
    )
    (FuncDef
      name: version-text
      body: 
        (BraceGroup
          children: [
            (C {(date)})
            (C {(echo)})
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:branch)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [(C {(git)} {(rev-parse)} {(--abbrev-ref)} {(HEAD)})]
                          )
                        left_token: <Left_CommandSub "$(">
                        spids: [465 473]
                      )
                    }
                  spids: [464]
                )
              ]
              spids: [462]
            )
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:hash)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [(C {(git)} {(rev-parse)} {($ VSub_Name "$branch")})]
                          )
                        left_token: <Left_CommandSub "$(">
                        spids: [479 485]
                      )
                    }
                  spids: [478]
                )
              ]
              spids: [476]
            )
            (C {(echo)} 
              {(DQ ("oil version: ") ($ VSub_Name "$hash") (" on branch ") ($ VSub_Name "$branch"))}
            )
            (C {(echo)})
            (SimpleCommand
              words: [{(python3)} {(--version)}]
              redirects: [(Redir op_id:Redir_GreatAnd fd:2 arg_word:{(1)} spids:[506])]
            )
            (C {(echo)})
            (Pipeline
              children: [(C {($ VSub_Name "$BASH")} {(--version)}) (C {(head)} {(-n)} {(1)})]
              negated: False
            )
            (C {(echo)})
            (Pipeline
              children: [(C {($ VSub_Name "$ZSH")} {(--version)}) (C {(head)} {(-n)} {(1)})]
              negated: False
            )
            (C {(echo)})
            (Pipeline
              children: [(C {(dpkg)} {(-s)} {(dash)}) (C {(egrep)} {(SQ <"^Package|Version">)})]
              negated: False
            )
            (C {(echo)})
            (Pipeline
              children: [(C {(dpkg)} {(-s)} {(mksh)}) (C {(egrep)} {(SQ <"^Package|Version">)})]
              negated: False
            )
            (C {(echo)})
            (Pipeline
              children: [
                (BraceGroup
                  children: [
                    (Sentence
                      child: (AndOr children:[(C {(busybox)})(C {(true)})] op_id:Op_DPipe)
                      terminator: <Op_Semi ";">
                    )
                  ]
                  spids: [594]
                )
                (C {(head)} {(-n)} {(1)})
              ]
              negated: False
            )
            (C {(echo)})
            (C {(maybe-show)} {(/etc/debian_version)})
            (C {(maybe-show)} {(/etc/lsb-release)})
          ]
          spids: [452]
        )
      spids: [448 451]
    )
    (FuncDef
      name: sh-spec
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:this_dir)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [
                              (AndOr
                                children: [
                                  (C {(cd)} 
                                    {
                                      (CommandSubPart
                                        command_list: 
                                          (CommandList
                                            children: [(C {(dirname)} {($ VSub_Number "$0")})]
                                          )
                                        left_token: <Left_CommandSub "$(">
                                        spids: [653 657]
                                      )
                                    }
                                  )
                                  (C {(pwd)})
                                ]
                                op_id: Op_DAmp
                              )
                            ]
                          )
                        left_token: <Left_CommandSub "$(">
                        spids: [650 662]
                      )
                    }
                  spids: [649]
                )
              ]
              spids: [647]
            )
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:tmp_env)
                  op: Equal
                  rhs: {($ VSub_Name "$this_dir") (/../_tmp/spec-tmp)}
                  spids: [668]
                )
              ]
              spids: [666]
            )
            (C {(mkdir)} {(-p)} {($ VSub_Name "$tmp_env")})
            (C {(test/sh_spec.py)} {(--tmp-env)} {($ VSub_Name "$tmp_env")} {(--path-env)} 
              {(DQ ($ VSub_Name "$this_dir") ("/../spec/bin:") ($ VSub_Name "$PATH"))} {(DQ ($ VSub_At "$@"))}
            )
          ]
          spids: [644]
        )
      spids: [640 643]
    )
    (FuncDef
      name: trace-var-sub
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_Local
              pairs: [(assign_pair lhs:(LhsName name:out) op:Equal rhs:{(_tmp/coverage)} spids:[730])]
              spids: [728]
            )
            (C {(mkdir)} {(-p)} {($ VSub_Name "$out")})
            (C {(python)} {(-m)} {(trace)} {(--trackcalls)} {(-C)} {($ VSub_Name "$out")} 
              {(test/sh_spec.py)} {(spec/var-sub.test.sh)} {($ VSub_Name "$DASH")} {($ VSub_Name "$BASH")} {(DQ ($ VSub_At "$@"))}
            )
            (C {(ls)} {(-l)} {($ VSub_Name "$out")})
            (C {(head)} {($ VSub_Name "$out") (/) (Lit_Other "*") (.cover)})
          ]
          spids: [725]
        )
      spids: [721 724]
    )
    (FuncDef
      name: all
      body: 
        (BraceGroup
          children: [(C {(test/spec-runner.sh)} {(all-parallel)} {(DQ ($ VSub_At "$@"))})]
          spids: [818]
        )
      spids: [814 817]
    )
    (FuncDef
      name: smoke
      body: 
        (BraceGroup
          children: [
            (C {(sh-spec)} {(spec/smoke.test.sh)} 
              {
                (BracedVarSub
                  token: <VSub_Name REF_SHELLS>
                  bracket_op: (WholeArray op_id:Lit_At)
                  spids: [863 868]
                )
              } {($ VSub_Name "$OSH")} {(DQ ($ VSub_At "$@"))}
            )
          ]
          spids: [856]
        )
      spids: [852 855]
    )
    (FuncDef
      name: osh-only
      body: 
        (BraceGroup
          children: [
            (C {(sh-spec)} {(spec/osh-only.test.sh)} {($ VSub_Name "$OSH")} {(DQ ($ VSub_At "$@"))})
          ]
          spids: [883]
        )
      spids: [879 882]
    )
    (FuncDef
      name: bugs
      body: 
        (BraceGroup
          children: [
            (C {(sh-spec)} {(spec/bugs.test.sh)} 
              {
                (BracedVarSub
                  token: <VSub_Name REF_SHELLS>
                  bracket_op: (WholeArray op_id:Lit_At)
                  spids: [913 918]
                )
              } {($ VSub_Name "$OSH")} {(DQ ($ VSub_At "$@"))}
            )
          ]
          spids: [906]
        )
      spids: [902 905]
    )
    (FuncDef
      name: blog1
      body: 
        (BraceGroup
          children: [
            (C {(sh-spec)} {(spec/blog1.test.sh)} 
              {
                (BracedVarSub
                  token: <VSub_Name REF_SHELLS>
                  bracket_op: (WholeArray op_id:Lit_At)
                  spids: [942 947]
                )
              } {($ VSub_Name "$ZSH")} {($ VSub_Name "$OSH")} {(DQ ($ VSub_At "$@"))}
            )
          ]
          spids: [933]
        )
      spids: [929 932]
    )
    (FuncDef
      name: blog2
      body: 
        (BraceGroup
          children: [
            (C {(sh-spec)} {(spec/blog2.test.sh)} 
              {
                (BracedVarSub
                  token: <VSub_Name REF_SHELLS>
                  bracket_op: (WholeArray op_id:Lit_At)
                  spids: [973 978]
                )
              } {($ VSub_Name "$ZSH")} {($ VSub_Name "$OSH")} {(DQ ($ VSub_At "$@"))}
            )
          ]
          spids: [964]
        )
      spids: [960 963]
    )
    (FuncDef
      name: blog-other1
      body: 
        (BraceGroup
          children: [
            (C {(sh-spec)} {(spec/blog-other1.test.sh)} 
              {
                (BracedVarSub
                  token: <VSub_Name REF_SHELLS>
                  bracket_op: (WholeArray op_id:Lit_At)
                  spids: [1004 1009]
                )
              } {($ VSub_Name "$ZSH")} {($ VSub_Name "$OSH")} {(DQ ($ VSub_At "$@"))}
            )
          ]
          spids: [995]
        )
      spids: [991 994]
    )
    (FuncDef
      name: comments
      body: 
        (BraceGroup
          children: [
            (C {(sh-spec)} {(spec/comments.test.sh)} 
              {
                (BracedVarSub
                  token: <VSub_Name REF_SHELLS>
                  bracket_op: (WholeArray op_id:Lit_At)
                  spids: [1033 1038]
                )
              } {($ VSub_Name "$OSH")} {(DQ ($ VSub_At "$@"))}
            )
          ]
          spids: [1026]
        )
      spids: [1022 1025]
    )
    (FuncDef
      name: word-split
      body: 
        (BraceGroup
          children: [
            (C {(sh-spec)} {(spec/word-split.test.sh)} {(--osh-failures-allowed)} {(3)} 
              {
                (BracedVarSub
                  token: <VSub_Name REF_SHELLS>
                  bracket_op: (WholeArray op_id:Lit_At)
                  spids: [1066 1071]
                )
              } {($ VSub_Name "$OSH")} {(DQ ($ VSub_At "$@"))}
            )
          ]
          spids: [1053]
        )
      spids: [1049 1052]
    )
    (FuncDef
      name: word-eval
      body: 
        (BraceGroup
          children: [
            (C {(sh-spec)} {(spec/word-eval.test.sh)} 
              {
                (BracedVarSub
                  token: <VSub_Name REF_SHELLS>
                  bracket_op: (WholeArray op_id:Lit_At)
                  spids: [1095 1100]
                )
              } {($ VSub_Name "$OSH")} {(DQ ($ VSub_At "$@"))}
            )
          ]
          spids: [1086]
        )
      spids: [1082 1085]
    )
    (FuncDef
      name: assign
      body: 
        (BraceGroup
          children: [
            (C {(sh-spec)} {(spec/assign.test.sh)} {(--osh-failures-allowed)} {(3)} 
              {
                (BracedVarSub
                  token: <VSub_Name REF_SHELLS>
                  bracket_op: (WholeArray op_id:Lit_At)
                  spids: [1131 1136]
                )
              } {($ VSub_Name "$OSH")} {(DQ ($ VSub_At "$@"))}
            )
          ]
          spids: [1118]
        )
      spids: [1114 1117]
    )
    (FuncDef
      name: background
      body: 
        (BraceGroup
          children: [
            (C {(sh-spec)} {(spec/background.test.sh)} 
              {
                (BracedVarSub
                  token: <VSub_Name REF_SHELLS>
                  bracket_op: (WholeArray op_id:Lit_At)
                  spids: [1161 1166]
                )
              } {($ VSub_Name "$OSH")} {(DQ ($ VSub_At "$@"))}
            )
          ]
          spids: [1152]
        )
      spids: [1148 1151]
    )
    (FuncDef
      name: subshell
      body: 
        (BraceGroup
          children: [
            (C {(sh-spec)} {(spec/subshell.test.sh)} 
              {
                (BracedVarSub
                  token: <VSub_Name REF_SHELLS>
                  bracket_op: (WholeArray op_id:Lit_At)
                  spids: [1191 1196]
                )
              } {($ VSub_Name "$OSH")} {(DQ ($ VSub_At "$@"))}
            )
          ]
          spids: [1182]
        )
      spids: [1178 1181]
    )
    (FuncDef
      name: quote
      body: 
        (BraceGroup
          children: [
            (C {(sh-spec)} {(spec/quote.test.sh)} {(--osh-failures-allowed)} {(4)} 
              {
                (BracedVarSub
                  token: <VSub_Name REF_SHELLS>
                  bracket_op: (WholeArray op_id:Lit_At)
                  spids: [1228 1233]
                )
              } {($ VSub_Name "$OSH")} {(DQ ($ VSub_At "$@"))}
            )
          ]
          spids: [1215]
        )
      spids: [1211 1214]
    )
    (FuncDef
      name: loop
      body: 
        (BraceGroup
          children: [
            (C {(sh-spec)} {(spec/loop.test.sh)} 
              {
                (BracedVarSub
                  token: <VSub_Name REF_SHELLS>
                  bracket_op: (WholeArray op_id:Lit_At)
                  spids: [1257 1262]
                )
              } {($ VSub_Name "$OSH")} {(DQ ($ VSub_At "$@"))}
            )
          ]
          spids: [1248]
        )
      spids: [1244 1247]
    )
    (FuncDef
      name: case_
      body: 
        (BraceGroup
          children: [
            (C {(sh-spec)} {(spec/case_.test.sh)} {(--osh-failures-allowed)} {(2)} 
              {
                (BracedVarSub
                  token: <VSub_Name REF_SHELLS>
                  bracket_op: (WholeArray op_id:Lit_At)
                  spids: [1293 1298]
                )
              } {($ VSub_Name "$OSH")} {(DQ ($ VSub_At "$@"))}
            )
          ]
          spids: [1280]
        )
      spids: [1276 1279]
    )
    (FuncDef
      name: if_
      body: 
        (BraceGroup
          children: [
            (C {(sh-spec)} {(spec/if_.test.sh)} {(--osh-failures-allowed)} {(1)} 
              {
                (BracedVarSub
                  token: <VSub_Name REF_SHELLS>
                  bracket_op: (WholeArray op_id:Lit_At)
                  spids: [1326 1331]
                )
              } {($ VSub_Name "$ZSH")} {($ VSub_Name "$OSH")} {(DQ ($ VSub_At "$@"))}
            )
          ]
          spids: [1313]
        )
      spids: [1309 1312]
    )
    (FuncDef
      name: builtins
      body: 
        (BraceGroup
          children: [
            (C {(sh-spec)} {(spec/builtins.test.sh)} {(--osh-failures-allowed)} {(3)} 
              {
                (BracedVarSub
                  token: <VSub_Name REF_SHELLS>
                  bracket_op: (WholeArray op_id:Lit_At)
                  spids: [1361 1366]
                )
              } {($ VSub_Name "$OSH")} {(DQ ($ VSub_At "$@"))}
            )
          ]
          spids: [1348]
        )
      spids: [1344 1347]
    )
    (FuncDef
      name: builtin-vars
      body: 
        (BraceGroup
          children: [
            (C {(sh-spec)} {(spec/builtin-vars.test.sh)} {(--osh-failures-allowed)} {(2)} 
              {
                (BracedVarSub
                  token: <VSub_Name REF_SHELLS>
                  bracket_op: (WholeArray op_id:Lit_At)
                  spids: [1394 1399]
                )
              } {($ VSub_Name "$OSH")} {(DQ ($ VSub_At "$@"))}
            )
          ]
          spids: [1381]
        )
      spids: [1377 1380]
    )
    (FuncDef
      name: builtin-getopts
      body: 
        (BraceGroup
          children: [
            (C {(sh-spec)} {(spec/builtin-getopts.test.sh)} {(--osh-failures-allowed)} {(1)} 
              {
                (BracedVarSub
                  token: <VSub_Name REF_SHELLS>
                  bracket_op: (WholeArray op_id:Lit_At)
                  spids: [1427 1432]
                )
              } {($ VSub_Name "$BUSYBOX_ASH")} {($ VSub_Name "$OSH")} {(DQ ($ VSub_At "$@"))}
            )
          ]
          spids: [1414]
        )
      spids: [1410 1413]
    )
    (FuncDef
      name: builtin-test
      body: 
        (BraceGroup
          children: [
            (C {(sh-spec)} {(spec/builtin-test.test.sh)} {(--osh-failures-allowed)} {(1)} 
              {
                (BracedVarSub
                  token: <VSub_Name REF_SHELLS>
                  bracket_op: (WholeArray op_id:Lit_At)
                  spids: [1462 1467]
                )
              } {($ VSub_Name "$OSH")} {(DQ ($ VSub_At "$@"))}
            )
          ]
          spids: [1449]
        )
      spids: [1445 1448]
    )
    (FuncDef
      name: builtin-type
      body: 
        (BraceGroup
          children: [
            (C {(sh-spec)} {(spec/builtin-type.test.sh)} {($ VSub_Name "$BASH")} {($ VSub_Name "$OSH")} 
              {(DQ ($ VSub_At "$@"))}
            )
          ]
          spids: [1485]
        )
      spids: [1481 1484]
    )
    (FuncDef
      name: builtins-special
      body: 
        (BraceGroup
          children: [
            (C {(sh-spec)} {(spec/builtins-special.test.sh)} {(--osh-failures-allowed)} {(3)} 
              {
                (BracedVarSub
                  token: <VSub_Name REF_SHELLS>
                  bracket_op: (WholeArray op_id:Lit_At)
                  spids: [1522 1527]
                )
              } {($ VSub_Name "$OSH")} {(DQ ($ VSub_At "$@"))}
            )
          ]
          spids: [1509]
        )
      spids: [1505 1508]
    )
    (FuncDef
      name: command-parsing
      body: 
        (BraceGroup
          children: [
            (C {(sh-spec)} {(spec/command-parsing.test.sh)} 
              {
                (BracedVarSub
                  token: <VSub_Name REF_SHELLS>
                  bracket_op: (WholeArray op_id:Lit_At)
                  spids: [1549 1554]
                )
              } {($ VSub_Name "$OSH")} {(DQ ($ VSub_At "$@"))}
            )
          ]
          spids: [1542]
        )
      spids: [1538 1541]
    )
    (FuncDef
      name: func-parsing
      body: 
        (BraceGroup
          children: [
            (C {(sh-spec)} {(spec/func-parsing.test.sh)} 
              {
                (BracedVarSub
                  token: <VSub_Name REF_SHELLS>
                  bracket_op: (WholeArray op_id:Lit_At)
                  spids: [1576 1581]
                )
              } {($ VSub_Name "$OSH")} {(DQ ($ VSub_At "$@"))}
            )
          ]
          spids: [1569]
        )
      spids: [1565 1568]
    )
    (FuncDef
      name: func
      body: 
        (BraceGroup
          children: [
            (C {(sh-spec)} {(spec/func.test.sh)} 
              {
                (BracedVarSub
                  token: <VSub_Name REF_SHELLS>
                  bracket_op: (WholeArray op_id:Lit_At)
                  spids: [1605 1610]
                )
              } {($ VSub_Name "$OSH")} {(DQ ($ VSub_At "$@"))}
            )
          ]
          spids: [1596]
        )
      spids: [1592 1595]
    )
    (FuncDef
      name: glob
      body: 
        (BraceGroup
          children: [
            (C {(sh-spec)} {(spec/glob.test.sh)} {(--osh-failures-allowed)} {(2)} 
              {
                (BracedVarSub
                  token: <VSub_Name REF_SHELLS>
                  bracket_op: (WholeArray op_id:Lit_At)
                  spids: [1638 1643]
                )
              } {($ VSub_Name "$BUSYBOX_ASH")} {($ VSub_Name "$OSH")} {(DQ ($ VSub_At "$@"))}
            )
          ]
          spids: [1625]
        )
      spids: [1621 1624]
    )
    (FuncDef
      name: arith
      body: 
        (BraceGroup
          children: [
            (C {(sh-spec)} {(spec/arith.test.sh)} {(--osh-failures-allowed)} {(3)} 
              {
                (BracedVarSub
                  token: <VSub_Name REF_SHELLS>
                  bracket_op: (WholeArray op_id:Lit_At)
                  spids: [1673 1678]
                )
              } {($ VSub_Name "$ZSH")} {($ VSub_Name "$OSH")} {(DQ ($ VSub_At "$@"))}
            )
          ]
          spids: [1660]
        )
      spids: [1656 1659]
    )
    (FuncDef
      name: command-sub
      body: 
        (BraceGroup
          children: [
            (C {(sh-spec)} {(spec/command-sub.test.sh)} {(--osh-failures-allowed)} {(2)} 
              {
                (BracedVarSub
                  token: <VSub_Name REF_SHELLS>
                  bracket_op: (WholeArray op_id:Lit_At)
                  spids: [1708 1713]
                )
              } {($ VSub_Name "$OSH")} {(DQ ($ VSub_At "$@"))}
            )
          ]
          spids: [1695]
        )
      spids: [1691 1694]
    )
    (FuncDef
      name: command_
      body: 
        (BraceGroup
          children: [
            (C {(sh-spec)} {(spec/command_.test.sh)} {(--osh-failures-allowed)} {(1)} 
              {
                (BracedVarSub
                  token: <VSub_Name REF_SHELLS>
                  bracket_op: (WholeArray op_id:Lit_At)
                  spids: [1741 1746]
                )
              } {($ VSub_Name "$OSH")} {(DQ ($ VSub_At "$@"))}
            )
          ]
          spids: [1728]
        )
      spids: [1724 1727]
    )
    (FuncDef
      name: pipeline
      body: 
        (BraceGroup
          children: [
            (C {(sh-spec)} {(spec/pipeline.test.sh)} {(--osh-failures-allowed)} {(3)} 
              {
                (BracedVarSub
                  token: <VSub_Name REF_SHELLS>
                  bracket_op: (WholeArray op_id:Lit_At)
                  spids: [1774 1779]
                )
              } {($ VSub_Name "$ZSH")} {($ VSub_Name "$OSH")} {(DQ ($ VSub_At "$@"))}
            )
          ]
          spids: [1761]
        )
      spids: [1757 1760]
    )
    (FuncDef
      name: explore-parsing
      body: 
        (BraceGroup
          children: [
            (C {(sh-spec)} {(spec/explore-parsing.test.sh)} 
              {
                (BracedVarSub
                  token: <VSub_Name REF_SHELLS>
                  bracket_op: (WholeArray op_id:Lit_At)
                  spids: [1805 1810]
                )
              } {($ VSub_Name "$OSH")} {(DQ ($ VSub_At "$@"))}
            )
          ]
          spids: [1796]
        )
      spids: [1792 1795]
    )
    (FuncDef
      name: parse-errors
      body: 
        (BraceGroup
          children: [
            (C {(sh-spec)} {(spec/parse-errors.test.sh)} {(--osh-failures-allowed)} {(4)} 
              {
                (BracedVarSub
                  token: <VSub_Name REF_SHELLS>
                  bracket_op: (WholeArray op_id:Lit_At)
                  spids: [1838 1843]
                )
              } {($ VSub_Name "$OSH")} {(DQ ($ VSub_At "$@"))}
            )
          ]
          spids: [1825]
        )
      spids: [1821 1824]
    )
    (FuncDef
      name: here-doc
      body: 
        (BraceGroup
          children: [
            (C {(sh-spec)} {(spec/here-doc.test.sh)} {(--osh-failures-allowed)} {(2)} {(--range)} {(0-27)} 
              {
                (BracedVarSub
                  token: <VSub_Name REF_SHELLS>
                  bracket_op: (WholeArray op_id:Lit_At)
                  spids: [1899 1904]
                )
              } {($ VSub_Name "$OSH")} {(DQ ($ VSub_At "$@"))}
            )
          ]
          spids: [1858]
        )
      spids: [1854 1857]
    )
    (FuncDef
      name: redirect
      body: 
        (BraceGroup
          children: [
            (C {(sh-spec)} {(spec/redirect.test.sh)} {(--osh-failures-allowed)} {(8)} 
              {
                (BracedVarSub
                  token: <VSub_Name REF_SHELLS>
                  bracket_op: (WholeArray op_id:Lit_At)
                  spids: [1932 1937]
                )
              } {($ VSub_Name "$OSH")} {(DQ ($ VSub_At "$@"))}
            )
          ]
          spids: [1919]
        )
      spids: [1915 1918]
    )
    (FuncDef
      name: posix
      body: 
        (BraceGroup
          children: [
            (C {(sh-spec)} {(spec/posix.test.sh)} 
              {
                (BracedVarSub
                  token: <VSub_Name REF_SHELLS>
                  bracket_op: (WholeArray op_id:Lit_At)
                  spids: [1961 1966]
                )
              } {($ VSub_Name "$OSH")} {(DQ ($ VSub_At "$@"))}
            )
          ]
          spids: [1952]
        )
      spids: [1948 1951]
    )
    (FuncDef
      name: special-vars
      body: 
        (BraceGroup
          children: [
            (C {(sh-spec)} {(spec/special-vars.test.sh)} {(--osh-failures-allowed)} {(4)} 
              {
                (BracedVarSub
                  token: <VSub_Name REF_SHELLS>
                  bracket_op: (WholeArray op_id:Lit_At)
                  spids: [1994 1999]
                )
              } {($ VSub_Name "$OSH")} {(DQ ($ VSub_At "$@"))}
            )
          ]
          spids: [1981]
        )
      spids: [1977 1980]
    )
    (FuncDef
      name: introspect
      body: 
        (BraceGroup
          children: [
            (C {(sh-spec)} {(spec/introspect.test.sh)} {($ VSub_Name "$BASH")} {($ VSub_Name "$OSH")} 
              {(DQ ($ VSub_At "$@"))}
            )
          ]
          spids: [2017]
        )
      spids: [2013 2016]
    )
    (FuncDef
      name: tilde
      body: 
        (BraceGroup
          children: [
            (C {(sh-spec)} {(spec/tilde.test.sh)} 
              {
                (BracedVarSub
                  token: <VSub_Name REF_SHELLS>
                  bracket_op: (WholeArray op_id:Lit_At)
                  spids: [2051 2056]
                )
              } {($ VSub_Name "$OSH")} {(DQ ($ VSub_At "$@"))}
            )
          ]
          spids: [2044]
        )
      spids: [2040 2043]
    )
    (FuncDef
      name: var-op-test
      body: 
        (BraceGroup
          children: [
            (C {(sh-spec)} {(spec/var-op-test.test.sh)} {(--osh-failures-allowed)} {(5)} 
              {
                (BracedVarSub
                  token: <VSub_Name REF_SHELLS>
                  bracket_op: (WholeArray op_id:Lit_At)
                  spids: [2084 2089]
                )
              } {($ VSub_Name "$OSH")} {(DQ ($ VSub_At "$@"))}
            )
          ]
          spids: [2071]
        )
      spids: [2067 2070]
    )
    (FuncDef
      name: var-op-other
      body: 
        (BraceGroup
          children: [
            (C {(sh-spec)} {(spec/var-op-other.test.sh)} {(--osh-failures-allowed)} {(5)} 
              {
                (BracedVarSub
                  token: <VSub_Name REF_SHELLS>
                  bracket_op: (WholeArray op_id:Lit_At)
                  spids: [2117 2122]
                )
              } {($ VSub_Name "$OSH")} {(DQ ($ VSub_At "$@"))}
            )
          ]
          spids: [2104]
        )
      spids: [2100 2103]
    )
    (FuncDef
      name: var-op-strip
      body: 
        (BraceGroup
          children: [
            (C {(sh-spec)} {(spec/var-op-strip.test.sh)} {(--osh-failures-allowed)} {(2)} 
              {
                (BracedVarSub
                  token: <VSub_Name REF_SHELLS>
                  bracket_op: (WholeArray op_id:Lit_At)
                  spids: [2150 2155]
                )
              } {($ VSub_Name "$ZSH")} {($ VSub_Name "$OSH")} {(DQ ($ VSub_At "$@"))}
            )
          ]
          spids: [2137]
        )
      spids: [2133 2136]
    )
    (FuncDef
      name: var-sub
      body: 
        (BraceGroup
          children: [
            (C {(sh-spec)} {(spec/var-sub.test.sh)} 
              {
                (BracedVarSub
                  token: <VSub_Name REF_SHELLS>
                  bracket_op: (WholeArray op_id:Lit_At)
                  spids: [2189 2194]
                )
              } {($ VSub_Name "$OSH")} {(DQ ($ VSub_At "$@"))}
            )
          ]
          spids: [2172]
        )
      spids: [2168 2171]
    )
    (FuncDef
      name: var-num
      body: 
        (BraceGroup
          children: [
            (C {(sh-spec)} {(spec/var-num.test.sh)} 
              {
                (BracedVarSub
                  token: <VSub_Name REF_SHELLS>
                  bracket_op: (WholeArray op_id:Lit_At)
                  spids: [2218 2223]
                )
              } {($ VSub_Name "$OSH")} {(DQ ($ VSub_At "$@"))}
            )
          ]
          spids: [2209]
        )
      spids: [2205 2208]
    )
    (FuncDef
      name: var-sub-quote
      body: 
        (BraceGroup
          children: [
            (C {(sh-spec)} {(spec/var-sub-quote.test.sh)} 
              {
                (BracedVarSub
                  token: <VSub_Name REF_SHELLS>
                  bracket_op: (WholeArray op_id:Lit_At)
                  spids: [2247 2252]
                )
              } {($ VSub_Name "$OSH")} {(DQ ($ VSub_At "$@"))}
            )
          ]
          spids: [2238]
        )
      spids: [2234 2237]
    )
    (FuncDef
      name: sh-options
      body: 
        (BraceGroup
          children: [
            (C {(sh-spec)} {(spec/sh-options.test.sh)} {(--osh-failures-allowed)} {(2)} 
              {
                (BracedVarSub
                  token: <VSub_Name REF_SHELLS>
                  bracket_op: (WholeArray op_id:Lit_At)
                  spids: [2280 2285]
                )
              } {($ VSub_Name "$OSH")} {(DQ ($ VSub_At "$@"))}
            )
          ]
          spids: [2267]
        )
      spids: [2263 2266]
    )
    (FuncDef
      name: errexit
      body: 
        (BraceGroup
          children: [
            (C {(sh-spec)} {(spec/errexit.test.sh)} 
              {
                (BracedVarSub
                  token: <VSub_Name REF_SHELLS>
                  bracket_op: (WholeArray op_id:Lit_At)
                  spids: [2309 2314]
                )
              } {($ VSub_Name "$BUSYBOX_ASH")} {($ VSub_Name "$OSH")} {(DQ ($ VSub_At "$@"))}
            )
          ]
          spids: [2300]
        )
      spids: [2296 2299]
    )
    (FuncDef
      name: arith-context
      body: 
        (BraceGroup
          children: [
            (C {(sh-spec)} {(spec/arith-context.test.sh)} {(--osh-failures-allowed)} {(7)} 
              {($ VSub_Name "$BASH")} {($ VSub_Name "$MKSH")} {($ VSub_Name "$ZSH")} {($ VSub_Name "$OSH")} {(DQ ($ VSub_At "$@"))}
            )
          ]
          spids: [2344]
        )
      spids: [2340 2343]
    )
    (FuncDef
      name: array
      body: 
        (BraceGroup
          children: [
            (C {(sh-spec)} {(spec/array.test.sh)} {(--osh-failures-allowed)} {(12)} 
              {($ VSub_Name "$BASH")} {($ VSub_Name "$MKSH")} {($ VSub_Name "$OSH")} {(DQ ($ VSub_At "$@"))}
            )
          ]
          spids: [2376]
        )
      spids: [2372 2375]
    )
    (FuncDef
      name: array-compat
      body: 
        (BraceGroup
          children: [
            (C {(sh-spec)} {(spec/array-compat.test.sh)} {(--osh-failures-allowed)} {(7)} 
              {($ VSub_Name "$BASH")} {($ VSub_Name "$MKSH")} {($ VSub_Name "$OSH")} {(DQ ($ VSub_At "$@"))}
            )
          ]
          spids: [2406]
        )
      spids: [2402 2405]
    )
    (FuncDef
      name: type-compat
      body: 
        (BraceGroup
          children: [
            (C {(sh-spec)} {(spec/type-compat.test.sh)} {($ VSub_Name "$BASH")} {(DQ ($ VSub_At "$@"))})
          ]
          spids: [2436]
        )
      spids: [2432 2435]
    )
    (FuncDef
      name: append
      body: 
        (BraceGroup
          children: [
            (C {(sh-spec)} {(spec/append.test.sh)} {(--osh-failures-allowed)} {(4)} 
              {($ VSub_Name "$BASH")} {($ VSub_Name "$MKSH")} {($ VSub_Name "$OSH")} {(DQ ($ VSub_At "$@"))}
            )
          ]
          spids: [2459]
        )
      spids: [2455 2458]
    )
    (FuncDef
      name: assoc
      body: 
        (BraceGroup
          children: [
            (C {(sh-spec)} {(spec/assoc.test.sh)} {($ VSub_Name "$BASH")} {(DQ ($ VSub_At "$@"))})
          ]
          spids: [2493]
        )
      spids: [2489 2492]
    )
    (FuncDef
      name: assoc-zsh
      body: 
        (BraceGroup
          children: [
            (C {(sh-spec)} {(spec/assoc-zsh.test.sh)} {($ VSub_Name "$ZSH")} {(DQ ($ VSub_At "$@"))})
          ]
          spids: [2516]
        )
      spids: [2512 2515]
    )
    (FuncDef
      name: dbracket
      body: 
        (BraceGroup
          children: [
            (C {(sh-spec)} {(spec/dbracket.test.sh)} {(--osh-failures-allowed)} {(5)} 
              {($ VSub_Name "$BASH")} {($ VSub_Name "$MKSH")} {($ VSub_Name "$OSH")} {(DQ ($ VSub_At "$@"))}
            )
          ]
          spids: [2542]
        )
      spids: [2538 2541]
    )
    (FuncDef
      name: dparen
      body: 
        (BraceGroup
          children: [
            (C {(sh-spec)} {(spec/dparen.test.sh)} {($ VSub_Name "$BASH")} {($ VSub_Name "$MKSH")} 
              {($ VSub_Name "$ZSH")} {($ VSub_Name "$OSH")} {(DQ ($ VSub_At "$@"))}
            )
          ]
          spids: [2576]
        )
      spids: [2572 2575]
    )
    (FuncDef
      name: brace-expansion
      body: 
        (BraceGroup
          children: [
            (C {(sh-spec)} {(spec/brace-expansion.test.sh)} {(--osh-failures-allowed)} {(12)} 
              {($ VSub_Name "$BASH")} {($ VSub_Name "$MKSH")} {($ VSub_Name "$ZSH")} {($ VSub_Name "$OSH")} {(DQ ($ VSub_At "$@"))}
            )
          ]
          spids: [2604]
        )
      spids: [2600 2603]
    )
    (FuncDef
      name: regex
      body: 
        (BraceGroup
          children: [
            (C {(sh-spec)} {(spec/regex.test.sh)} {(--osh-failures-allowed)} {(2)} {($ VSub_Name "$BASH")} 
              {($ VSub_Name "$ZSH")} {($ VSub_Name "$OSH")} {(DQ ($ VSub_At "$@"))}
            )
          ]
          spids: [2640]
        )
      spids: [2636 2639]
    )
    (FuncDef
      name: process-sub
      body: 
        (BraceGroup
          children: [
            (C {(sh-spec)} {(spec/process-sub.test.sh)} {(--osh-failures-allowed)} {(2)} 
              {($ VSub_Name "$BASH")} {($ VSub_Name "$ZSH")} {($ VSub_Name "$OSH")} {(DQ ($ VSub_At "$@"))}
            )
          ]
          spids: [2670]
        )
      spids: [2666 2669]
    )
    (FuncDef
      name: extended-glob
      body: 
        (BraceGroup
          children: [
            (C {(sh-spec)} {(spec/extended-glob.test.sh)} {($ VSub_Name "$BASH")} {($ VSub_Name "$MKSH")} 
              {(DQ ($ VSub_At "$@"))}
            )
          ]
          spids: [2704]
        )
      spids: [2700 2703]
    )
    (FuncDef
      name: var-ref
      body: 
        (BraceGroup
          children: [
            (C {(sh-spec)} {(spec/var-ref.test.sh)} {(--osh-failures-allowed)} {(5)} 
              {($ VSub_Name "$BASH")} {($ VSub_Name "$MKSH")} {($ VSub_Name "$OSH")} {(DQ ($ VSub_At "$@"))}
            )
          ]
          spids: [2733]
        )
      spids: [2729 2732]
    )
    (FuncDef
      name: let
      body: 
        (BraceGroup
          children: [
            (C {(sh-spec)} {(spec/let.test.sh)} {($ VSub_Name "$BASH")} {($ VSub_Name "$MKSH")} 
              {($ VSub_Name "$ZSH")} {(DQ ($ VSub_At "$@"))}
            )
          ]
          spids: [2763]
        )
      spids: [2759 2762]
    )
    (FuncDef
      name: for-expr
      body: 
        (BraceGroup
          children: [
            (C {(sh-spec)} {(spec/for-expr.test.sh)} {(--osh-failures-allowed)} {(2)} 
              {($ VSub_Name "$MKSH")} {($ VSub_Name "$BASH")} {($ VSub_Name "$OSH")} {(DQ ($ VSub_At "$@"))}
            )
          ]
          spids: [2787]
        )
      spids: [2783 2786]
    )
    (FuncDef
      name: shell-grammar
      body: 
        (BraceGroup
          children: [
            (C {(sh-spec)} {(spec/shell-grammar.test.sh)} {($ VSub_Name "$BASH")} {($ VSub_Name "$MKSH")} 
              {($ VSub_Name "$ZSH")} {(DQ ($ VSub_At "$@"))}
            )
          ]
          spids: [2823]
        )
      spids: [2819 2822]
    )
    (C {(DQ ($ VSub_At "$@"))})
  ]
)