Stable version 0.4.4

This release is dedicated to AlphaGo,
embodying the second golden age of AI.

.github/ISSUE_TEMPLATE.md

@@ -1,27 +0,0 @@
-#### For bugs
-- Rule Id (if any, e.g. SC1000): 
-- My shellcheck version (`shellcheck --version` or "online"): 
-- [ ] I tried on shellcheck.net and verified that this is still a problem on the latest commit
-- [ ] It's not reproducible on shellcheck.net, but I think that's because it's an OS, configuration or encoding issue
-
-#### For new checks and feature suggestions
-- [ ] shellcheck.net (i.e. the latest commit) currently gives no useful warnings about this
-- [ ] I searched through https://github.com/koalaman/shellcheck/issues and didn't find anything related
-
-
-#### Here's a snippet or screenshot that shows the problem:
-
-```sh
-
-#!/your/interpreter
-your script here
-
-```
-
-#### Here's what shellcheck currently says:
-
-
-
-#### Here's what I wanted or expected to see:
-
-

.prepare_deploy

@@ -1,42 +0,0 @@
-#!/bin/bash
-# This script packages up Travis compiled binaries
-set -ex
-shopt -s nullglob
-cd deploy
-
-cp ../LICENSE LICENSE.txt
-sed -e $'s/$/\r/' > README.txt << END
-This is a precompiled ShellCheck binary.
-      http://www.shellcheck.net/
-
-ShellCheck is a static analysis tool for shell scripts.
-It's licensed under the GNU General Public License v3.0.
-Information and source code is available on the website.
-
-This binary was compiled on $(date -u).
-
-
-
-      ====== Latest commits ======
-
-$(git log -n 3)
-END
-
-for file in ./*.exe
-do
-  zip "${file%.*}.zip" README.txt LICENSE.txt "$file"
-done
-
-for file in *.linux
-do
-  base="${file%.*}"
-  cp "$file" "shellcheck"
-  tar -cJf "$base.linux.x86_64.tar.xz" --transform="s:^:$base/:" README.txt LICENSE.txt shellcheck
-  rm "shellcheck"
-done
-
-for file in ./*
-do
-  sha512sum "$file" > "$file.sha512sum"
-done
-

.travis.yml

@@ -1,72 +0,0 @@
-sudo: required
-
-language: sh
-
-services:
-  - docker
-
-before_install:
-  - DOCKER_BASE="$DOCKER_USERNAME/shellcheck"
-  - DOCKER_BUILDS=""
-  - TAGS=""
-  - test "$TRAVIS_BRANCH" = master && TAGS="$TAGS latest" || true
-  - test -n "$TRAVIS_TAG"          && TAGS="$TAGS $TRAVIS_TAG" || true
-  - test "$TRAVIS_BRANCH" = master && test -n "$TRAVIS_TAG" && TAGS="$TAGS stable" || true
-
-script:
-  - mkdir deploy
-  # Windows .exe
-  - docker pull koalaman/winghc
-  - docker run --user="$UID" --rm -v "$PWD:/appdata" koalaman/winghc cuib
-  - for tag in $TAGS; do cp "dist/build/ShellCheck/shellcheck.exe" "deploy/shellcheck-$tag.exe"; done
-  - rm -rf dist || true
-  # Linux static executable
-  - docker pull koalaman/scbuilder
-  - docker run --user="$UID" --rm -v "$PWD:/mnt" koalaman/scbuilder
-  - for tag in $TAGS; do cp "shellcheck" "deploy/shellcheck-$tag.linux"; done
-  - ./shellcheck --version
-  - rm -rf dist || true
-  # Linux Docker image
-  - name="$DOCKER_BASE"
-  - DOCKER_BUILDS="$DOCKER_BUILDS $name"
-  - docker build -t "$name:current" .
-  - docker run "$name:current" --version
-  # Linux Alpine based Docker image
-  - name="$DOCKER_BASE-alpine"
-  - DOCKER_BUILDS="$DOCKER_BUILDS $name"
-  - sed 's/^FROM .*/FROM alpine:latest/' Dockerfile > Dockerfile.alpine
-  - docker build -f Dockerfile.alpine -t "$name:current" .
-  - docker run "$name:current" --version
-  # Misc packaging
-  - ./.prepare_deploy
-
-after_success:
-  - docker login -e="$DOCKER_EMAIL" -u="$DOCKER_USERNAME" -p="$DOCKER_PASSWORD"
-  - for repo in $DOCKER_BUILDS;
-    do
-      for tag in $TAGS;
-      do
-        echo "Deploying $repo:current as $repo:$tag...";
-        docker tag "$repo:current" "$repo:$tag";
-        docker push "$repo:$tag";
-      done;
-    done;
-
-after_failure:
-  - id
-  - pwd
-  - df -h
-  - find . -name '*.log' -type f -exec grep "" /dev/null {} +
-  - find . -ls
-
-deploy:
-  provider: gcs
-  skip_cleanup: true
-  access_key_id: GOOG7MDN7WEH6IIGBDCA
-  secret_access_key:
-    secure: Bcx2cT0/E2ikj7sdamVq52xlLZF9dz9ojGPtoKfPyQhkkZa+McVI4xgUSuyyoSxyKj77sofx2y8m6PJYYumT4g5hREV1tfeUkl0J2DQFMbGDYEt7kxVkXCxojNvhHwTzLFv0ezstrxWWxQm81BfQQ4U9lggRXtndAP4czZnOeHPINPSiue1QNwRAEw05r5UoIUJXy/5xyUrjIxn381pAs+gJqP2COeN9kTKYH53nS/AAws29RprfZFnPlo7xxWmcjRcdS5KPdGXI/c6tQp5zl2iTh510VC1PN2w1Wvnn/oNWhiNdqPyVDsojIX5+sS3nejzJA+KFMxXSBlyXIY3wPpS/MdscU79X6Q5f9ivsFfsm7gNBmxHUPNn0HAvU4ROT/CCE9j6jSbs5PC7QBo3CK4++jxAwE/pd9HUc2rs3k0ofx3rgveJ7txpy5yPKfwIIBi98kVKlC4w7dLvNTOfjW1Imt2yH87XTfsE0UIG9st1WII6s4l/WgBx2GuwKdt6+3QUYiAlCFckkxWi+fAvpHZUEL43Qxub5fN+ZV7Zib1n7opchH4QKGBb6/y0WaDCmtCfu0lppoe/TH6saOTjDFj67NJSElK6ZDxGZ3uw4R+ret2gm6WRKT2Oeub8J33VzSa7VkmFpMPrAAfPa9N1Z4ewBLoTmvxSg2A0dDrCdJio=
-  bucket: shellcheck
-  local-dir: deploy
-  on:
-    repo: koalaman/shellcheck
-    all_branches: true

CHANGELOG.md

@@ -1,309 +0,0 @@
-## v0.4.7 - 2017-12-08
-### Added
-- Statically linked binaries for Linux and Windows (see README.md)!
-- `-a` flag to also include warnings in `source`d files
-- SC2221/SC2222: Warn about overridden case branches
-- SC2220: Warn about unhandled error cases in getopt loops
-- SC2218: Warn when using functions before they're defined
-- SC2216/SC2217: Warn when piping/redirecting to mv/cp and other non-readers
-- SC2215: Warn about commands starting with leading dash
-- SC2214: Warn about superfluous getopt flags
-- SC2213: Warn about unhandled getopt flags
-- SC2212: Suggest `false` over `[ ]`
-- SC2211: Warn when using a glob as a command name
-- SC2210: Warn when redirecting to an integer, e.g. `foo 1>2`
-- SC2206/SC2207: Suggest alternatives when using word splitting in arrays
-- SC1117: Warn about double quoted, undefined backslash sequences
-- SC1113/SC1114/SC1115: Recognized more malformed shebangs
-
-### Fixed
-- `[ -v foo ]` no longer warns if `foo` is undefined
-- SC2037 is now suppressed by quotes, e.g. `PAGER="cat" man foo`
-- Ksh nested array declarations now parse correctly
-- Parameter Expansion without colons are now recognized, e.g. `${foo+bar}`
-- The `lastpipe` option is now respected with regard to subshell warnings
-- `\(` is now respected for grouping in `[`
-- Leading `\` is now ignored for commands, to allow alias suppression
-- Comments are now allowed after directives to e.g. explain 'disable'
-
-
-## v0.4.6 - 2017-03-26
-### Added
-- SC2204/SC2205: Warn about `( -z foo )` and `( foo -eq bar )`
-- SC2200/SC2201: Warn about brace expansion in [/[[
-- SC2198/SC2199: Warn about arrays in [/[[
-- SC2196/SC2197: Warn about deprected egrep/fgrep
-- SC2195: Warn about unmatchable case branches
-- SC2194: Warn about constant 'case' statements
-- SC2193: Warn about `[[ file.png == *.mp3 ]]` and other unmatchables
-- SC2188/SC2189: Warn about redirections without commands
-- SC2186: Warn about deprecated `tempfile`
-- SC1109: Warn when finding `&`/`>`/`<` unquoted
-- SC1108: Warn about missing spaces in `[ var= foo ]`
-
-### Changed
-- All files are now read as UTF-8 with lenient latin1 fallback, ignoring locale
-- Unicode quotes are no longer considered syntactic quotes
-- `ash` scripts will now be checked as `dash` with a warning
-
-### Fixed
-- `-c` no longer suggested when using `grep -o | wc`
-- Comments and whitespace are now allowed before filewide directives
-- Here doc delimters with esoteric quoting like `foo""` are now handled
-- SC2095 about `ssh` in while read loops is now suppressed when using `-n`
-- `%(%Y%M%D)T` now recognized as a single formatter in `printf` checks
-- `grep -F` now suppresses regex related suggestions
-- Command name checks now recognize busybox applet names
-
-
-## v0.4.5 - 2016-10-21
-### Added
-- A Docker build (thanks, kpankonen!)
-- SC2185: Suggest explicitly adding path for `find`
-- SC2184: Warn about unsetting globs (e.g. `unset foo[1]`)
-- SC2183: Warn about `printf` with more formatters than variables
-- SC2182: Warn about ignored arguments with `printf` 
-- SC2181: Suggest using command directly instead of `if [ $? -eq 0 ]`
-- SC1106: Warn when using `test` operators in `(( 1 -eq 2 ))`
-
-### Changed
-- Unrecognized directives now causes a warning rather than parse failure.
-
-### Fixed
-- Indices in associative arrays are now parsed correctly
-- Missing shebang warning squashed when specifying with a directive
-- Ksh multidimensional arrays are now supported
-- Variables in substring ${a:x:y} expansions now count as referenced
-- SC1102 now also handles ambiguous `$((`
-- Using `$(seq ..)` will no longer suggest quoting
-- SC2148 (missing shebang) is now suppressed when using shell directives
-- `[ a '>' b ]` is now recognized as being correctly escaped
-
-
-## v0.4.4 - 2016-05-15
-### Added
-- Haskell Stack support (thanks,  Arguggi!)
-- SC2179/SC2178: Warn when assigning/appending strings to arrays
-- SC1102: Warn about ambiguous `$(((`
-- SC1101: Warn when \\ linebreaks have trailing spaces
-
-### Changed
-- Directives directly after the shebang now apply to the entire file
-
-### Fixed
-- `{$i..10}` is now flagged similar to `{1..$i}`
-
-
-## v0.4.3 - 2016-01-13
-### Fixed
-- Build now works on GHC 7.6.3 as found on Debian Stable/Ubuntu LTS
-
-
-## v0.4.2 - 2016-01-09
-### Added
-- First class support for the `dash` shell
-- The `--color` flag similar to ls/grep's (thanks, haguenau!)
-- SC2174: Warn about unexpected behavior of `mkdir -pm` (thanks, eatnumber1!)
-- SC2172: Warn about non-portable use of signal numbers in `trap`
-- SC2171: Warn about `]]` without leading `[[`
-- SC2168: Warn about `local` outside functions
-
-### Fixed
-- Warnings about unchecked `cd` will no longer trigger with `set -e`
-- `[ a -nt/-ot/-ef b ]` no longer warns about being constant
-- Quoted test operators like `[ foo "<" bar ]` now parse
-- Escaped quotes in backticks now parse correctly
-
-
-## v0.4.1 - 2015-09-05
-### Fixed
-- Added missing files to Cabal, fixing the build
-
-
-## v0.4.0 - 2015-09-05
-### Added
-- Support for following `source`d files
-- Support for setting default flags in `SHELLCHECK_OPTS`
-- An `--external-sources` flag for following arbitrary `source`d files
-- A `source` directive to override the filename to `source`
-- SC2166: Suggest using `[ p ] && [ q ]` over `[ p -a q ]`
-- SC2165: Warn when nested `for` loops use the same variable name
-- SC2164: Warn when using `cd` without checking that it succeeds
-- SC2163: Warn about `export $var`
-- SC2162: Warn when using `read` without `-r`
-- SC2157: Warn about `[ "$var " ]` and similar never-empty string matches
-
-### Fixed
-- `cat -vnE file` and similar will no longer flag as UUOC
-- Nested trinary operators in `(( ))` now parse correctly
-- Ksh `${ ..; }` command expansions now parse
-
-
-## v0.3.8 - 2015-06-20
-### Changed
-- ShellCheck's license has changed from AGPLv3 to GPLv3.
-
-### Added
-- SC2156: Warn about injecting filenames in `find -exec sh -c "{}" \;`
-
-### Fixed
-- Variables and command substitutions in brace expansions are now parsed
-- ANSI colors are now disabled on Windows
-- Empty scripts now parse
-
-
-## v0.3.7 - 2015-04-16
-### Fixed
-- Build now works on GHC 7.10
-- Use `regex-tdfa` over `regex-compat` since the latter crashes on OS X.
-
-## v0.3.6 - 2015-03-28
-### Added
-- SC2155: Warn about masked return values in `export foo=$(exit 1)`
-- SC2154: Warn when a lowercase variable is referenced but not assigned
-- SC2152/SC2151: Warn about bad `return` values like `1234` and `"foo"`
-- SC2150: Warn about `find -exec "shell command" \;`
-
-### Fixed
-- `coproc` is now supported
-- Trinary operator now recognized in `((..))`
-
-### Removed
-- Zsh support has been removed
-
-
-## v0.3.5 - 2014-11-09
-### Added
-- SC2148: Warn when not including a shebang
-- SC2147: Warn about literal ~ in PATH
-- SC1086: Warn about `$` in for loop variables, e.g. `for $i in ..`
-- SC1084: Warn when the shebang uses `!#` instead of `#!`
-
-### Fixed
-- Empty and comment-only backtick expansions now parse
-- Variables used in PS1/PROMPT\_COMMAND/trap now count as referenced
-- ShellCheck now skips unreadable files and directories
-- `-f gcc` on empty files no longer crashes
-- Variables in $".." are now considered quoted
-- Warnings about expansions in single quotes now include backticks
-
-
-## v0.3.4 - 2014-07-08
-### Added
-- SC2146: Warn about precedence when combining `find -o` with actions
-- SC2145: Warn when concatenating arrays and strings
-
-### Fixed
-- Case statements now support `;&` and `;;&`
-- Indices in array declarations now parse correctly
-- `let` expressions now parsed as arithmetic expressions
-- Escaping is now respected in here documents
-
-### Changed
-- Completely drop Makefile in favor of Cabal (thanks rodrigosetti!)
-
-
-## v0.3.3 - 2014-05-29
-### Added
-- SC2144: Warn when using globs in `[/[[`
-- SC2143: Suggesting using `grep -q` over `[ "$(.. | grep)" ]`
-- SC2142: Warn when referencing positional parameters in aliases
-- SC2141: Warn about suspicious IFS assignments like `IFS="\n"`
-- SC2140: Warn about bad embedded quotes like `echo "var="value""`
-- SC2130: Warn when using `-eq` on strings
-- SC2139: Warn about define time expansions in alias definitions
-- SC2129: Suggest command grouping over `a >> log; b >> log; c >> log`
-- SC2128: Warn when expanding arrays without an index
-- SC2126: Suggest `grep -c` over `grep|wc`
-- SC2123: Warn about accidentally overriding `$PATH`, e.g. `PATH=/my/dir`
-- SC1083: Warn about literal `{/}` outside of quotes
-- SC1082: Warn about UTF-8 BOMs
-
-### Fixed
-- SC2051 no longer triggers for `{1,$n}`, only `{1..$n}`
-- Improved detection of single quoted `sed` variables, e.g. `sed '$s///'`
-- Stop warning about single quoted variables in `PS1` and similar
-- Support for Zsh short form loops, `=(..)`
-
-### Removed
-- SC1000 about unescaped lonely `$`, e.g. `grep "^foo$"`
-
-
-## v0.3.2 - 2014-03-22
-### Added
-- SC2121: Warn about trying to `set` variables, e.g. `set var = value`
-- SC2120/SC2119: Warn when a function uses `$1..` if none are ever passed
-- SC2117: Warn when using `su` in interactive mode, e.g. `su foo; whoami` 
-- SC2116: Detect useless use of echo, e.g. `for i in $(echo $var)`
-- SC2115/SC2114: Detect some catastrophic `rm -r "$empty/"` mistakes
-- SC1081: Warn when capitalizing keywords like `While`
-- SC1077: Warn when using acute accents instead of backticks
-
-### Fixed
-- Shells are now properly recognized in shebangs containing flags
-- Stop warning about math on decimals in ksh/zsh
-- Stop warning about decimal comparisons with `=`, e.g. `[ $version = 1.2 ]`
-- Parsing of `|&`
-- `${a[x]}` not counting as a reference of `x`
-- `(( x[0] ))` not counting as a reference of `x`
-
-
-## v0.3.1 - 2014-02-03
-### Added
-- The `-s` flag to specify shell dialect
-- SC2105/SC2104: Warn about `break/continue` outside loops
-- SC1076: Detect invalid `[/[[` arithmetic like `[ 1 + 2 = 3 ]`
-- SC1075: Suggest using `elif` over `else if`
-
-### Fixed
-- Don't warn when comma separating elements in brace expansions
-- Improved detection of single quoted `sed` variables, e.g. `sed '$d'`
-- Parsing of arithmetic for loops using `{..}` instead of `do..done`
-- Don't treat the last pipeline stage as a subshell in ksh/zsh
-
-
-## v0.3.0 - 2014-01-19
-### Added
-- A man page (thanks Dridi!)
-- GCC compatible error reporting (`shellcheck -f gcc`)
-- CheckStyle compatible XML error reporting (`shellcheck -f checkstyle`)
-- Error codes for each warning, e.g. SC1234
-- Allow disabling warnings with `# shellcheck disable=SC1234`
-- Allow disabling warnings with `--exclude`
-- SC2103: Suggest using subshells over `cd foo; bar; cd ..`
-- SC2102: Warn about duplicates in char ranges, e.g. `[10-15]`
-- SC2101: Warn about named classes not inside a char range, e.g. `[:digit:]`
-- SC2100/SC2099: Warn about bad math expressions like `i=i+5`
-- SC2098/SC2097: Warn about `foo=bar echo $foo`
-- SC2095: Warn when using `ssh`/`ffmpeg` in `while read` loops
-- Better warnings for missing here doc tokens
-
-### Fixed
-- Don't warn when single quoting variables with `ssh/perl/eval`
-- `${!var}` is now counted as a variable reference
-
-### Removed
-- Suggestions about using parameter expansion over basename
-- The `jsoncheck` binary. Use `shellcheck -f json` instead. 
-
-
-## v0.2.0 - 2013-10-27
-### Added
-- Suggest `./*` instead of `*` when passing globs to commands
-- Suggest `pgrep` over `ps | grep`
-- Warn about unicode quotes
-- Warn about assigned but unused variables
-- Inform about client side expansion when using `ssh`
-
-### Fixed
-- CLI tool now uses exit codes and stderr canonically
-- Parsing of extglobs containing empty patterns
-- Parsing of bash style `eval foo=(bar)`
-- Parsing of expansions in here documents
-- Parsing of function names containing :+-
-- Don't warn about `find|xargs` when using `-print0`
-
-
-## v0.1.0 - 2013-07-23
-### Added
-- First release

Dockerfile

@@ -1,10 +0,0 @@
-FROM scratch
-
-LABEL maintainer="Vidar Holen <vidar@vidarholen.net>"
-
-# This file assumes ShellCheck has already been built.
-# See https://github.com/koalaman/scbuilder
-COPY shellcheck /bin/shellcheck
-
-WORKDIR /mnt
-ENTRYPOINT ["/bin/shellcheck"]

README.md

@@ -6,67 +6,39 @@ ShellCheck is a GPLv3 tool that gives warnings and suggestions for bash/sh shell
 
 The goals of ShellCheck are
 
-- To point out and clarify typical beginner's syntax issues that cause a shell
-  to give cryptic error messages.
+  - To point out and clarify typical beginner's syntax issues
+    that cause a shell to give cryptic error messages.
 
-- To point out and clarify typical intermediate level semantic problems that
-  cause a shell to behave strangely and counter-intuitively.
+  - To point out and clarify typical intermediate level semantic problems
+    that cause a shell to behave strangely and counter-intuitively.
 
-- To point out subtle caveats, corner cases and pitfalls that may cause an
-  advanced user's otherwise working script to fail under future circumstances.
+  - To point out subtle caveats, corner cases and pitfalls that may cause an
+    advanced user's otherwise working script to fail under future circumstances.
 
 See [the gallery of bad code](README.md#user-content-gallery-of-bad-code) for examples of what ShellCheck can help you identify!
 
-## Table of Contents
-
-- [How to use](#how-to-use)
-  - [On the web](#on-the-web)
-  - [From your terminal](#from-your-terminal)
-  - [In your editor](#in-your-editor)
-  - [In your build or test suites](#in-your-build-or-test-suites)
-- [Installing](#installing)
-- [Travis CI Setup](#travis-ci-setup)
-- [Compiling from source](#compiling-from-source)
-  - [Installing Cabal](#installing-cabal)
-  - [Compiling ShellCheck](#compiling-shellcheck)
-  - [Running tests](#running-tests)
-- [Gallery of bad code](#gallery-of-bad-code)
-  - [Quoting](#quoting)
-  - [Conditionals](#conditionals)
-  - [Frequently misused commands](#frequently-misused-commands)
-  - [Common beginner's mistakes](#common-beginners-mistakes)
-  - [Style](#style)
-  - [Data and typing errors](#data-and-typing-errors)
-  - [Robustness](#robustness)
-  - [Portability](#portability)
-  - [Miscellaneous](#miscellaneous)
-- [Testimonials](#testimonials)
-- [Ignoring issues](#ignoring-issues)
-- [Reporting bugs](#reporting-bugs)
-- [Contributing](#contributing)
-- [Copyright](#copyright)
 
 ## How to use
+There are a variety of ways to use ShellCheck!
 
-There are a number of ways to use ShellCheck!
-
-### On the web
 
+#### On the web
 Paste a shell script on http://www.shellcheck.net for instant feedback.
 
-[ShellCheck.net](http://www.shellcheck.net) is always synchronized to the latest git commit, and is the easiest way to give ShellCheck a go. Tell your friends!
+[ShellCheck.net](http://www.shellcheck.net) is always synchronized to the latest git commit, and is the simplest way to give ShellCheck a go. Tell your friends!
 
-### From your terminal
 
+#### From your terminal
 Run `shellcheck yourscript` in your terminal for instant output, as seen above.
 
-### In your editor
+
+#### In your editor
 
 You can see ShellCheck suggestions directly in a variety of editors.
 
-* Vim, through [ALE](https://github.com/w0rp/ale), [Neomake](https://github.com/neomake/neomake), or [Syntastic](https://github.com/scrooloose/syntastic):
+* Vim, through [Syntastic](https://github.com/scrooloose/syntastic):
 
-![Screenshot of Vim showing inlined shellcheck feedback](doc/vim-syntastic.png).
+![Screenshot of vim showing inlined shellcheck feedback](doc/vim-syntastic.png).
 
 * Emacs, through [Flycheck](https://github.com/flycheck/flycheck):
 
@@ -76,15 +48,14 @@ You can see ShellCheck suggestions directly in a variety of editors.
 
 * Atom, through [Linter](https://github.com/AtomLinter/linter-shellcheck).
 
-* VSCode, through [vscode-shellcheck](https://github.com/timonwong/vscode-shellcheck).
-
 * Most other editors, through [GCC error compatibility](shellcheck.1.md#user-content-formats).
 
-### In your build or test suites
 
+#### In your build or test suites
 While ShellCheck is mostly intended for interactive use, it can easily be added to builds or test suites.
 
-ShellCheck makes canonical use of exit codes, and can output simple JSON, CheckStyle compatible XML, GCC compatible warnings as well as human readable text (with or without ANSI colors). See the [Integration](https://github.com/koalaman/shellcheck/wiki/Integration) wiki page for more documentation.
+Use ShellCheck's exit code, or its [CheckStyle compatible XML output](shellcheck.1.md#user-content-formats). There's also a simple JSON output format for easy integration.
+
 
 ## Installing
 
@@ -93,30 +64,12 @@ The easiest way to install ShellCheck locally is through your package manager.
 On systems with Cabal (installs to `~/.cabal/bin`):
 
     cabal update
-    cabal install ShellCheck
+    cabal install shellcheck
 
-On systems with Stack (installs to `~/.local/bin`):
-
-    stack update
-    stack install ShellCheck
-    
 On Debian based distros:
 
     apt-get install shellcheck
 
-On Arch Linux based distros:
-
-    pacman -S shellcheck
-
-On Gentoo based distros:
-
-    emerge --ask shellcheck
-
-On EPEL based distros:
-
-    yum -y install epel-release
-    yum install ShellCheck
-
 On Fedora based distros:
 
     dnf install ShellCheck
@@ -135,61 +88,22 @@ On openSUSE:Tumbleweed:
 
 On other openSUSE distributions:
 
-Add OBS devel:languages:haskell repository from https://build.opensuse.org/project/repositories/devel:languages:haskell
+add OBS devel:languages:haskell repository from https://build.opensuse.org/project/repositories/devel:languages:haskell
 
     zypper ar http://download.opensuse.org/repositories/devel:/languages:/haskell/openSUSE_$(version)/devel:languages:haskell.repo
     zypper in ShellCheck
 
-Or use OneClickInstall - https://software.opensuse.org/package/ShellCheck
-
-On Solus:
-
-    eopkg install shellcheck
-
-From Docker Hub:
-
-```sh
-docker pull koalaman/shellcheck:latest  # Or  :v0.4.6  for a release version
-docker run -v "$PWD:/mnt" koalaman/shellcheck myscript
-```
-
-or use `koalaman/shellcheck-alpine` if you want a larger Alpine Linux based image to extend.
-
-Alternatively, get freshly built binaries for the latest commit here:
-
-* [Linux, x86_64](https://storage.googleapis.com/shellcheck/shellcheck-latest.linux.x86_64.tar.xz) (statically linked)
-* [Windows, x86](https://storage.googleapis.com/shellcheck/shellcheck-latest.zip)
-
-or see the [storage bucket listing](https://shellcheck.storage.googleapis.com/index.html) for checksums and release builds.
-
-## Travis CI Setup
-
-If you want to use ShellCheck in Travis CI, you can most easily install it via `apt`:
-
-```yml
-language: bash
-addons:
-  apt:
-    sources:
-    - debian-sid    # Grab ShellCheck from the Debian repo
-    packages:
-    - shellcheck
-```
+or use OneClickInstall - https://software.opensuse.org/package/ShellCheck
 
 
 ## Compiling from source
 
 This section describes how to build ShellCheck from a source directory. ShellCheck is written in Haskell and requires 2GB of RAM to compile.
 
-### Installing Cabal
 
-ShellCheck is built and packaged using Cabal. Install the package `cabal-install` from your system's package manager (with e.g. `apt-get`, `brew`, `emerge`, `yum`, or `zypper`).
+#### Installing Cabal
 
-On MacOS (OS X), you can do a fast install of Cabal using brew, which takes a couple of minutes instead of more than 30 minutes if you try to compile it from source.
-
-    brew install cask
-    brew cask install haskell-platform
-    cabal install cabal-install
+ShellCheck is built and packaged using Cabal. Install the package `cabal-install` from your system's package manager (with e.g. `apt-get`, `yum`, `zypper` or `brew`).
 
 On MacPorts, the package is instead called `hs-cabal-install`, while native Windows users should install the latest version of the Haskell platform from https://www.haskell.org/platform/
 
@@ -197,30 +111,22 @@ Verify that `cabal` is installed and update its dependency list with
 
     $ cabal update
 
-### Compiling ShellCheck
+#### Compiling ShellCheck
 
 `git clone` this repository, and `cd` to the ShellCheck source directory to build/install:
 
     $ cabal install
 
-Or if you intend to run the tests:
-
-    $ cabal install --enable-tests
-
 This will compile ShellCheck and install it to your `~/.cabal/bin` directory.
 
 Add this directory to your `PATH` (for bash, add this to your `~/.bashrc`):
 
-```sh
-export PATH="$HOME/.cabal/bin:$PATH"
-```
+    export PATH="$HOME/.cabal/bin:$PATH"
 
 Log out and in again, and verify that your PATH is set up correctly:
 
-```sh
-$ which shellcheck
-~/.cabal/bin/shellcheck
-```
+    $ which shellcheck
+    ~/.cabal/bin/shellcheck
 
 On native Windows, the `PATH` should already be set up, but the system
 may use a legacy codepage. In `cmd.exe`, `powershell.exe` and Powershell ISE,
@@ -234,161 +140,147 @@ In Powershell ISE, you may need to additionally update the output encoding:
 
     > [Console]::OutputEncoding = [System.Text.Encoding]::UTF8
 
-### Running tests
+#### Running tests
 
 To run the unit test suite:
 
     $ cabal test
 
-## Gallery of bad code
 
+## Gallery of bad code
 So what kind of things does ShellCheck look for? Here is an incomplete list of detected issues.
 
-### Quoting
+#### Quoting
 
 ShellCheck can recognize several types of incorrect quoting:
 
-```sh
-echo $1                           # Unquoted variables
-find . -name *.ogg                # Unquoted find/grep patterns
-rm "~/my file.txt"                # Quoted tilde expansion
-v='--verbose="true"'; cmd $v      # Literal quotes in variables
-for f in "*.ogg"                  # Incorrectly quoted 'for' loops
-touch $@                          # Unquoted $@
-echo 'Don't forget to restart!'   # Singlequote closed by apostrophe
-echo 'Don\'t try this at home'    # Attempting to escape ' in ''
-echo 'Path is $PATH'              # Variables in single quotes
-trap "echo Took ${SECONDS}s" 0    # Prematurely expanded trap
-```
+    echo $1                           # Unquoted variables
+    find . -name *.ogg                # Unquoted find/grep patterns
+    rm "~/my file.txt"                # Quoted tilde expansion
+    v='--verbose="true"'; cmd $v      # Literal quotes in variables
+    for f in "*.ogg"                  # Incorrectly quoted 'for' loops
+    touch $@                          # Unquoted $@
+    echo 'Don't forget to restart!'   # Singlequote closed by apostrophe
+    echo 'Don\'t try this at home'    # Attempting to escape ' in ''
+    echo 'Path is $PATH'              # Variables in single quotes
+    trap "echo Took ${SECONDS}s" 0    # Prematurely expanded trap
 
-### Conditionals
+
+#### Conditionals
 
 ShellCheck can recognize many types of incorrect test statements.
 
-```sh
-[[ n != 0 ]]                      # Constant test expressions
-[[ -e *.mpg ]]                    # Existence checks of globs
-[[ $foo==0 ]]                     # Always true due to missing spaces
-[[ -n "$foo " ]]                  # Always true due to literals
-[[ $foo =~ "fo+" ]]               # Quoted regex in =~
-[ foo =~ re ]                     # Unsupported [ ] operators
-[ $1 -eq "shellcheck" ]           # Numerical comparison of strings
-[ $n && $m ]                      # && in [ .. ]
-[ grep -q foo file ]              # Command without $(..)
-[[ "$$file" == *.jpg ]]           # Comparisons that can't succeed
-(( 1 -lt 2 ))                     # Using test operators in ((..))
-```
+    [[ n != 0 ]]                      # Constant test expressions
+    [[ -e *.mpg ]]                    # Existence checks of globs
+    [[ $foo==0 ]]                     # Always true due to missing spaces
+    [[ -n "$foo " ]]                  # Always true due to literals
+    [[ $foo =~ "fo+" ]]               # Quoted regex in =~
+    [ foo =~ re ]                     # Unsupported [ ] operators
+    [ $1 -eq "shellcheck" ]           # Numerical comparison of strings
+    [ $n && $m ]                      # && in [ .. ]
+    [ grep -q foo file ]              # Command without $(..)
 
-### Frequently misused commands
+
+#### Frequently misused commands
 
 ShellCheck can recognize instances where commands are used incorrectly:
 
-```sh
-grep '*foo*' file                 # Globs in regex contexts
-find . -exec foo {} && bar {} \;  # Prematurely terminated find -exec
-sudo echo 'Var=42' > /etc/profile # Redirecting sudo
-time --format=%s sleep 10         # Passing time(1) flags to time builtin
-while read h; do ssh "$h" uptime  # Commands eating while loop input
-alias archive='mv $1 /backup'     # Defining aliases with arguments
-tr -cd '[a-zA-Z0-9]'              # [] around ranges in tr
-exec foo; echo "Done!"            # Misused 'exec'
-find -name \*.bak -o -name \*~ -delete  # Implicit precedence in find
-f() { whoami; }; sudo f           # External use of internal functions
-```
+    grep '*foo*' file                 # Globs in regex contexts
+    find . -exec foo {} && bar {} \;  # Prematurely terminated find -exec
+    sudo echo 'Var=42' > /etc/profile # Redirecting sudo
+    time --format=%s sleep 10         # Passing time(1) flags to time builtin
+    while read h; do ssh "$h" uptime  # Commands eating while loop input
+    alias archive='mv $1 /backup'     # Defining aliases with arguments
+    tr -cd '[a-zA-Z0-9]'              # [] around ranges in tr
+    exec foo; echo "Done!"            # Misused 'exec'
+    find -name \*.bak -o -name \*~ -delete  # Implicit precedence in find
+    f() { whoami; }; sudo f           # External use of internal functions
 
-### Common beginner's mistakes
+
+#### Common beginner's mistakes
 
 ShellCheck recognizes many common beginner's syntax errors:
 
-```sh
-var = 42                          # Spaces around = in assignments
-$foo=42                           # $ in assignments
-for $var in *; do ...             # $ in for loop variables
-var$n="Hello"                     # Wrong indirect assignment
-echo ${var$n}                     # Wrong indirect reference
-var=(1, 2, 3)                     # Comma separated arrays
-array=( [index] = value )         # Incorrect index initialization
-echo "Argument 10 is $10"         # Positional parameter misreference
-if $(myfunction); then ..; fi     # Wrapping commands in $()
-else if othercondition; then ..   # Using 'else if'
-```
+    var = 42                          # Spaces around = in assignments
+    $foo=42                           # $ in assignments
+    for $var in *; do ...             # $ in for loop variables
+    var$n="Hello"                     # Wrong indirect assignment
+    echo ${var$n}                     # Wrong indirect reference
+    var=(1, 2, 3)                     # Comma separated arrays
+    echo "Argument 10 is $10"         # Positional parameter misreference
+    if $(myfunction); then ..; fi     # Wrapping commands in $()
+    else if othercondition; then ..   # Using 'else if'
 
-### Style
+
+#### Style
 
 ShellCheck can make suggestions to improve style:
 
-```sh
-[[ -z $(find /tmp | grep mpg) ]]  # Use grep -q instead
-a >> log; b >> log; c >> log      # Use a redirection block instead
-echo "The time is `date`"         # Use $() instead
-cd dir; process *; cd ..;         # Use subshells instead
-echo $[1+2]                       # Use standard $((..)) instead of old $[]
-echo $(($RANDOM % 6))             # Don't use $ on variables in $((..))
-echo "$(date)"                    # Useless use of echo
-cat file | grep foo               # Useless use of cat
-```
+    [[ -z $(find /tmp | grep mpg) ]]  # Use grep -q instead
+    a >> log; b >> log; c >> log      # Use a redirection block instead
+    echo "The time is `date`"         # Use $() instead
+    cd dir; process *; cd ..;         # Use subshells instead
+    echo $[1+2]                       # Use standard $((..)) instead of old $[]
+    echo $(($RANDOM % 6))             # Don't use $ on variables in $((..))
+    echo "$(date)"                    # Useless use of echo
+    cat file | grep foo               # Useless use of cat
 
-### Data and typing errors
+
+#### Data and typing errors
 
 ShellCheck can recognize issues related to data and typing:
 
-```sh
-args="$@"                         # Assigning arrays to strings
-files=(foo bar); echo "$files"    # Referencing arrays as strings
-declare -A arr=(foo bar)          # Associative arrays without index
-printf "%s\n" "Arguments: $@."    # Concatenating strings and arrays
-[[ $# > 2 ]]                      # Comparing numbers as strings
-var=World; echo "Hello " var      # Unused lowercase variables
-echo "Hello $name"                # Unassigned lowercase variables
-cmd | read bar; echo $bar         # Assignments in subshells
-```
+    args="$@"                         # Assigning arrays to strings
+    files=(foo bar); echo "$files"    # Referencing arrays as strings
+    printf "%s\n" "Arguments: $@."    # Concatenating strings and arrays.
+    [[ $# > 2 ]]                      # Comparing numbers as strings
+    var=World; echo "Hello " var      # Unused lowercase variables
+    echo "Hello $name"                # Unassigned lowercase variables
+    cmd | read bar; echo $bar         # Assignments in subshells
 
-### Robustness
+
+#### Robustness
 
 ShellCheck can make suggestions for improving the robustness of a script:
 
-```sh
-rm -rf "$STEAMROOT/"*            # Catastrophic rm
-touch ./-l; ls *                 # Globs that could become options
-find . -exec sh -c 'a && b {}' \; # Find -exec shell injection
-printf "Hello $name"             # Variables in printf format
-for f in $(ls *.txt); do         # Iterating over ls output
-export MYVAR=$(cmd)              # Masked exit codes
-```
+    rm -rf "$STEAMROOT/"*            # Catastrophic rm
+    touch ./-l; ls *                 # Globs that could become options
+    find . -exec sh -c 'a && b {}' \; # Find -exec shell injection
+    printf "Hello $name"             # Variables in printf format
+    for f in $(ls *.txt); do         # Iterating over ls output
+    export MYVAR=$(cmd)              # Masked exit codes
 
-### Portability
+
+#### Portability
 
 ShellCheck will warn when using features not supported by the shebang. For example, if you set the shebang to `#!/bin/sh`, ShellCheck will warn about portability issues similar to `checkbashisms`:
 
-```sh
-echo {1..$n}                     # Works in ksh, but not bash/dash/sh
-echo {1..10}                     # Works in ksh and bash, but not dash/sh
-echo -n 42                       # Works in ksh, bash and dash, undefined in sh
-trap 'exit 42' sigint            # Unportable signal spec
-cmd &> file                      # Unportable redirection operator
-read foo < /dev/tcp/host/22      # Unportable intercepted files
-foo-bar() { ..; }                # Undefined/unsupported function name
-[ $UID = 0 ]                     # Variable undefined in dash/sh
-local var=value                  # local is undefined in sh
-time sleep 1 | sleep 5           # Undefined uses of 'time'
-```
 
-### Miscellaneous
+    echo {1..$n}                     # Works in ksh, but not bash/dash/sh
+    echo {1..10}                     # Works in ksh and bash, but not dash/sh
+    echo -n 42                       # Works in ksh, bash and dash, undefined in sh
+    trap 'exit 42' sigint            # Unportable signal spec
+    cmd &> file                      # Unportable redirection operator
+    read foo < /dev/tcp/host/22      # Unportable intercepted files
+    foo-bar() { ..; }                # Undefined/unsupported function name
+    [ $UID = 0 ]                     # Variable undefined in dash/sh
+    local var=value                  # local is undefined in sh
+
+
+#### Miscellaneous
 
 ShellCheck recognizes a menagerie of other issues:
 
-```sh
-PS1='\e[0;32m\$\e[0m '            # PS1 colors not in \[..\]
-PATH="$PATH:~/bin"                # Literal tilde in $PATH
-rm “file”                         # Unicode quotes
-echo "Hello world"                # Carriage return / DOS line endings
-echo hello \                      # Trailing spaces after \
-var=42 echo $var                  # Expansion of inlined environment
-#!/bin/bash -x -e                 # Common shebang errors
-echo $((n/180*100))               # Unnecessary loss of precision
-ls *[:digit:].txt                 # Bad character class globs
-sed 's/foo/bar/' file > file      # Redirecting to input
-```
+    PS1='\e[0;32m\$\e[0m '            # PS1 colors not in \[..\]
+    PATH="$PATH:~/bin"                # Literal tilde in $PATH
+    rm “file”                         # Unicode quotes
+    echo "Hello world"                # Carriage return / DOS line endings
+    var=42 echo $var                  # Expansion of inlined environment
+    #!/bin/bash -x -e                 # Common shebang errors
+    echo $((n/180*100))               # Unnecessary loss of precision
+    ls *[:digit:].txt                 # Bad character class globs
+    sed 's/foo/bar/' file > file       # Redirecting to input
+
 
 ## Testimonials
 
@@ -397,11 +289,6 @@ sed 's/foo/bar/' file > file      # Redirecting to input
 Alexander Tarasikov,
 [via Twitter](https://twitter.com/astarasikov/status/568825996532707330)
 
-## Ignoring issues
-
-Issues can be ignored via environmental variable, command line, individually or globally within a file:
-
-https://github.com/koalaman/shellcheck/wiki/Ignore
 
 ## Reporting bugs
 
@@ -409,15 +296,15 @@ Please use the GitHub issue tracker for any bugs or feature suggestions:
 
 https://github.com/koalaman/shellcheck/issues
 
+
 ## Contributing
 
-Please submit patches to code or documentation as GitHub pull requests! Check
-out the [DevGuide](https://github.com/koalaman/shellcheck/wiki/DevGuide) on the
-ShellCheck Wiki.
+Please submit patches to code or documentation as GitHub pull requests!
 
 Contributions must be licensed under the GNU GPLv3.
 The contributor retains the copyright.
 
+
 ## Copyright
 
 ShellCheck is licensed under the GNU General Public License, v3. A copy of this license is included in the file [LICENSE](LICENSE).

ShellCheck.cabal

@@ -1,5 +1,5 @@
 Name:             ShellCheck
-Version:          0.4.7
+Version:          0.4.4
 Synopsis:         Shell script analysis tool
 License:          GPL-3
 License-file:     LICENSE
@@ -55,7 +55,6 @@ library
       ShellCheck.AnalyzerLib
       ShellCheck.Checker
       ShellCheck.Checks.Commands
-      ShellCheck.Checks.ShellSupport
       ShellCheck.Data
       ShellCheck.Formatter.Format
       ShellCheck.Formatter.CheckStyle
@@ -70,6 +69,7 @@ library
 
 executable shellcheck
     build-depends:
+      ShellCheck,
       base >= 4 && < 5,
       containers,
       directory,
@@ -83,6 +83,7 @@ executable shellcheck
 test-suite test-shellcheck
     type: exitcode-stdio-1.0
     build-depends:
+      ShellCheck,
       base >= 4 && < 5,
       containers,
       directory,

ShellCheck/AST.hs

@@ -19,21 +19,19 @@
 -}
 module ShellCheck.AST where
 
+import Control.Monad
 import Control.Monad.Identity
-import Text.Parsec
 import qualified ShellCheck.Regex as Re
-import Prelude hiding (id)
 
-newtype Id = Id Int deriving (Show, Eq, Ord)
+data Id = Id Int deriving (Show, Eq, Ord)
 
 data Quoted = Quoted | Unquoted deriving (Show, Eq)
 data Dashed = Dashed | Undashed deriving (Show, Eq)
 data AssignmentMode = Assign | Append deriving (Show, Eq)
-newtype FunctionKeyword = FunctionKeyword Bool deriving (Show, Eq)
-newtype FunctionParentheses = FunctionParentheses Bool deriving (Show, Eq)
+data FunctionKeyword = FunctionKeyword Bool deriving (Show, Eq)
+data FunctionParentheses = FunctionParentheses Bool deriving (Show, Eq)
 data CaseType = CaseBreak | CaseFallThrough | CaseContinue deriving (Show, Eq)
 
-newtype Root = Root Token
 data Token =
     TA_Binary Id String Token Token
     | TA_Assignment Id String Token Token
@@ -45,18 +43,15 @@ data Token =
     | TC_And Id ConditionType String Token Token
     | TC_Binary Id ConditionType String Token Token
     | TC_Group Id ConditionType Token
-    | TC_Nullary Id ConditionType Token
+    | TC_Noary Id ConditionType Token
     | TC_Or Id ConditionType String Token Token
     | TC_Unary Id ConditionType String Token
-    | TC_Empty Id ConditionType
     | T_AND_IF Id
-    | T_AndIf Id Token Token
+    | T_AndIf Id (Token) (Token)
     | T_Arithmetic Id Token
     | T_Array Id [Token]
-    | T_IndexedElement Id [Token] Token
-    -- Store the index as string, and parse as arithmetic or string later
-    | T_UnparsedIndex Id SourcePos String
-    | T_Assignment Id AssignmentMode String [Token] Token
+    | T_IndexedElement Id Token Token
+    | T_Assignment Id AssignmentMode String (Maybe Token) Token
     | T_Backgrounded Id Token
     | T_Backticked Id [Token]
     | T_Bang Id
@@ -101,7 +96,6 @@ data Token =
     | T_IfExpression Id [([Token],[Token])] [Token]
     | T_In  Id
     | T_IoFile Id Token Token
-    | T_IoDuplicate Id Token String
     | T_LESSAND Id
     | T_LESSGREAT Id
     | T_Lbrace Id
@@ -111,8 +105,7 @@ data Token =
     | T_NEWLINE Id
     | T_NormalWord Id [Token]
     | T_OR_IF Id
-    | T_OrIf Id Token Token
-    | T_ParamSubSpecialChar Id String -- e.g. '%' in ${foo%bar}  or '/' in ${foo/bar/baz}
+    | T_OrIf Id (Token) (Token)
     | T_Pipeline Id [Token] [Token] -- [Pipe separators] [Commands]
     | T_ProcSub Id String [Token]
     | T_Rbrace Id
@@ -152,7 +145,7 @@ tokenEquals a b = kludge a == kludge b
 instance Eq Token where
     (==) = tokenEquals
 
-analyze :: Monad m => (Token -> m ()) -> (Token -> m ()) -> (Token -> m Token) -> Token -> m Token
+analyze :: Monad m => (Token -> m ()) -> (Token -> m ()) -> (Token -> Token) -> Token -> m Token
 analyze f g i =
     round
   where
@@ -160,9 +153,14 @@ analyze f g i =
         f t
         newT <- delve t
         g t
-        i newT
+        return . i $ newT
     roundAll = mapM round
 
+    roundMaybe Nothing = return Nothing
+    roundMaybe (Just v) = do
+        s <- round v
+        return (Just s)
+
     dl l v = do
         x <- roundAll l
         return $ v x
@@ -188,18 +186,14 @@ analyze f g i =
     delve (T_DollarArithmetic id c) = d1 c $ T_DollarArithmetic id
     delve (T_DollarBracket id c) = d1 c $ T_DollarBracket id
     delve (T_IoFile id op file) = d2 op file $ T_IoFile id
-    delve (T_IoDuplicate id op num) = d1 op $ \x -> T_IoDuplicate id x num
     delve (T_HereString id word) = d1 word $ T_HereString id
     delve (T_FdRedirect id v t) = d1 t $ T_FdRedirect id v
-    delve (T_Assignment id mode var indices value) = do
-        a <- roundAll indices
+    delve (T_Assignment id mode var index value) = do
+        a <- roundMaybe index
         b <- round value
         return $ T_Assignment id mode var a b
     delve (T_Array id t) = dl t $ T_Array id
-    delve (T_IndexedElement id indices t) = do
-        a <- roundAll indices
-        b <- round t
-        return $ T_IndexedElement id a b
+    delve (T_IndexedElement id t1 t2) = d2 t1 t2 $ T_IndexedElement id
     delve (T_Redirecting id redirs cmd) = do
         a <- roundAll redirs
         b <- round cmd
@@ -254,7 +248,7 @@ analyze f g i =
     delve (TC_Group id typ token) = d1 token $ TC_Group id typ
     delve (TC_Binary id typ op lhs rhs) = d2 lhs rhs $ TC_Binary id typ op
     delve (TC_Unary id typ op token) = d1 token $ TC_Unary id typ op
-    delve (TC_Nullary id typ token) = d1 token $ TC_Nullary id typ
+    delve (TC_Noary id typ token) = d1 token $ TC_Noary id typ
 
     delve (TA_Binary id op t1 t2) = d2 t1 t2 $ TA_Binary id op
     delve (TA_Assignment id op t1 t2) = d2 t1 t2 $ TA_Assignment id op
@@ -273,7 +267,6 @@ analyze f g i =
     delve (T_Include id includer script) = d2 includer script $ T_Include id
     delve t = return t
 
-getId :: Token -> Id
 getId t = case t of
         T_AND_IF id  -> id
         T_OR_IF id  -> id
@@ -317,10 +310,8 @@ getId t = case t of
         T_DollarBraced id _  -> id
         T_DollarArithmetic id _  -> id
         T_BraceExpansion id _  -> id
-        T_ParamSubSpecialChar id _ -> id
         T_DollarBraceCommandExpansion id _  -> id
         T_IoFile id _ _  -> id
-        T_IoDuplicate id _ _  -> id
         T_HereDoc id _ _ _ _ -> id
         T_HereString id _  -> id
         T_FdRedirect id _ _  -> id
@@ -353,7 +344,7 @@ getId t = case t of
         TC_Group id _ _  -> id
         TC_Binary id _ _ _ _  -> id
         TC_Unary id _ _ _  -> id
-        TC_Nullary id _ _  -> id
+        TC_Noary id _ _  -> id
         TA_Binary id _ _ _  -> id
         TA_Assignment id _ _ _  -> id
         TA_Unary id _ _  -> id
@@ -372,15 +363,10 @@ getId t = case t of
         T_CoProc id _ _ -> id
         T_CoProcBody id _ -> id
         T_Include id _ _ -> id
-        T_UnparsedIndex id _ _ -> id
-        TC_Empty id _ -> id
 
 blank :: Monad m => Token -> m ()
 blank = const $ return ()
-doAnalysis :: Monad m => (Token -> m ()) -> Token -> m Token
-doAnalysis f = analyze f blank return
-doStackAnalysis :: Monad m => (Token -> m ()) -> (Token -> m ()) -> Token -> m Token
-doStackAnalysis startToken endToken = analyze startToken endToken return
-doTransform :: (Token -> Token) -> Token -> Token
-doTransform i = runIdentity . analyze blank blank (return . i)
+doAnalysis f = analyze f blank id
+doStackAnalysis startToken endToken = analyze startToken endToken id
+doTransform i = runIdentity . analyze blank blank i
 

ShellCheck/ASTLib.hs

@@ -21,9 +21,7 @@ module ShellCheck.ASTLib where
 
 import ShellCheck.AST
 
-import Control.Monad.Writer
 import Control.Monad
-import Data.Functor
 import Data.List
 import Data.Maybe
 
@@ -48,16 +46,14 @@ willSplit x =
     T_NormalWord _ l -> any willSplit l
     _ -> False
 
-isGlob T_Extglob {} = True
-isGlob T_Glob {} = True
+isGlob (T_Extglob {}) = True
+isGlob (T_Glob {}) = True
 isGlob (T_NormalWord _ l) = any isGlob l
 isGlob _ = False
 
 -- Is this shell word a constant?
 isConstant token =
     case token of
-        -- This ignores some cases like ~"foo":
-        T_NormalWord _ (T_Literal _ ('~':_) : _)  -> False
         T_NormalWord _ l   -> all isConstant l
         T_DoubleQuoted _ l -> all isConstant l
         T_SingleQuoted _ _ -> True
@@ -87,14 +83,13 @@ oversimplify token =
         (T_Glob _ s) -> [s]
         (T_Pipeline _ _ [x]) -> oversimplify x
         (T_Literal _ x) -> [x]
-        (T_ParamSubSpecialChar _ x) -> [x]
         (T_SimpleCommand _ vars words) -> concatMap oversimplify words
         (T_Redirecting _ _ foo) -> oversimplify foo
         (T_DollarSingleQuoted _ s) -> [s]
         (T_Annotation _ _ s) -> oversimplify s
         -- Workaround for let "foo = bar" parsing
         (TA_Sequence _ [TA_Expansion _ v]) -> concatMap oversimplify v
-        _ -> []
+        otherwise -> []
 
 
 -- Turn a SimpleCommand foo -avz --bar=baz into args "a", "v", "z", "bar",
@@ -113,22 +108,9 @@ getFlagsUntil _ _ = error "Internal shellcheck error, please report! (getFlags o
 
 -- Get all flags in a GNU way, up until --
 getAllFlags = getFlagsUntil (== "--")
--- Get all flags in a BSD way, up until first non-flag argument or --
-getLeadingFlags = getFlagsUntil (\x -> x == "--" || (not $ "-" `isPrefixOf` x))
+-- Get all flags in a BSD way, up until first non-flag argument
+getLeadingFlags = getFlagsUntil (not . ("-" `isPrefixOf`))
 
--- Check if a command has a flag.
-hasFlag cmd str = str `elem` (map snd $ getAllFlags cmd)
-
--- Is this token a word that starts with a dash?
-isFlag token =
-    case getWordParts token of
-        T_Literal _ ('-':_) : _ -> True
-        _ -> False
-
--- Is this token a flag where the - is unquoted?
-isUnquotedFlag token = fromMaybe False $ do
-    str <- getLeadingUnquotedString token
-    return $ "-" `isPrefixOf` str
 
 -- Given a T_DollarBraced, return a simplified version of the string contents.
 bracedString (T_DollarBraced _ l) = concat $ oversimplify l
@@ -154,9 +136,9 @@ mayBecomeMultipleArgs t = willBecomeMultipleArgs t || f t
 -- Is it certain that this word will becomes multiple words?
 willBecomeMultipleArgs t = willConcatInAssignment t || f t
   where
-    f T_Extglob {} = True
-    f T_Glob {} = True
-    f T_BraceExpansion {} = True
+    f (T_Extglob {}) = True
+    f (T_Glob {}) = True
+    f (T_BraceExpansion {}) = True
     f (T_DoubleQuoted _ parts) = any f parts
     f (T_NormalWord _ parts) = any f parts
     f _ = False
@@ -164,7 +146,7 @@ willBecomeMultipleArgs t = willConcatInAssignment t || f t
 -- This does token cause implicit concatenation in assignments?
 willConcatInAssignment token =
     case token of
-        t@T_DollarBraced {} -> isArrayExpansion t
+        t@(T_DollarBraced {}) -> isArrayExpansion t
         (T_DoubleQuoted _ parts) -> any willConcatInAssignment parts
         (T_NormalWord _ parts) -> any willConcatInAssignment parts
         _ -> False
@@ -179,33 +161,12 @@ onlyLiteralString = fromJust . getLiteralStringExt (const $ return "")
 
 -- Maybe get a literal string, but only if it's an unquoted argument.
 getUnquotedLiteral (T_NormalWord _ list) =
-    concat <$> mapM str list
+    liftM concat $ mapM str list
   where
     str (T_Literal _ s) = return s
     str _ = Nothing
 getUnquotedLiteral _ = Nothing
 
--- Get the last unquoted T_Literal in a word like "${var}foo"THIS
--- or nothing if the word does not end in an unquoted literal.
-getTrailingUnquotedLiteral :: Token -> Maybe Token
-getTrailingUnquotedLiteral t =
-    case t of
-        (T_NormalWord _ list@(_:_)) ->
-            from (last list)
-        _ -> Nothing
-  where
-    from t =
-        case t of
-            T_Literal {} -> return t
-            _ -> Nothing
-
--- Get the leading, unquoted, literal string of a token (if any).
-getLeadingUnquotedString :: Token -> Maybe String
-getLeadingUnquotedString t =
-    case t of
-        T_NormalWord _ ((T_Literal _ s) : _) -> return s
-        _ -> Nothing
-
 -- Maybe get the literal string of this token and any globs in it.
 getGlobOrLiteralString = getLiteralStringExt f
   where
@@ -217,14 +178,13 @@ getGlobOrLiteralString = getLiteralStringExt f
 getLiteralStringExt :: (Token -> Maybe String) -> Token -> Maybe String
 getLiteralStringExt more = g
   where
-    allInList = fmap concat . mapM g
+    allInList = liftM concat . mapM g
     g (T_DoubleQuoted _ l) = allInList l
     g (T_DollarDoubleQuoted _ l) = allInList l
     g (T_NormalWord _ l) = allInList l
     g (TA_Expansion _ l) = allInList l
     g (T_SingleQuoted _ s) = return s
     g (T_Literal _ s) = return s
-    g (T_ParamSubSpecialChar _ s) = return s
     g x = more x
 
 -- Is this token a string literal?
@@ -234,8 +194,6 @@ isLiteral t = isJust $ getLiteralString t
 -- Turn a NormalWord like foo="bar $baz" into a series of constituent elements like [foo=,bar ,$baz]
 getWordParts (T_NormalWord _ l)   = concatMap getWordParts l
 getWordParts (T_DoubleQuoted _ l) = l
--- TA_Expansion is basically T_NormalWord for arithmetic expressions
-getWordParts (TA_Expansion _ l)   = concatMap getWordParts l
 getWordParts other                = [other]
 
 -- Return a list of NormalWords that would result from brace expansion
@@ -248,41 +206,16 @@ braceExpand (T_NormalWord id list) = take 1000 $ do
         braceExpand item
     part x = return x
 
--- Maybe get a SimpleCommand from immediate wrappers like T_Redirections
-getCommand t =
-    case t of
-        T_Redirecting _ _ w -> getCommand w
-        T_SimpleCommand _ _ (w:_) -> return t
-        T_Annotation _ _ t -> getCommand t
-        _ -> Nothing
-
 -- Maybe get the command name of a token representing a command
-getCommandName t = do
-    (T_SimpleCommand _ _ (w:rest)) <- getCommand t
-    s <- getLiteralString w
-    if "busybox" `isSuffixOf` s
-        then
-            case rest of
-                (applet:_) -> getLiteralString applet
-                _ -> return s
-        else
-            return s
-
--- If a command substitution is a single command, get its name.
---  $(date +%s) = Just "date"
-getCommandNameFromExpansion :: Token -> Maybe String
-getCommandNameFromExpansion t =
+getCommandName t =
     case t of
-        T_DollarExpansion _ [c] -> extract c
-        T_Backticked _ [c] -> extract c
-        T_DollarBraceCommandExpansion _ [c] -> extract c
-        _ -> Nothing
-  where
-    extract (T_Pipeline _ _ [cmd]) = getCommandName cmd
-    extract _ = Nothing
+        T_Redirecting _ _ w -> getCommandName w
+        T_SimpleCommand _ _ (w:_) -> getLiteralString w
+        T_Annotation _ _ t -> getCommandName t
+        otherwise -> Nothing
 
 -- Get the basename of a token representing a command
-getCommandBasename = fmap basename . getCommandName
+getCommandBasename = liftM basename . getCommandName
   where
     basename = reverse . takeWhile (/= '/') . reverse
 
@@ -292,7 +225,7 @@ isAssignment t =
         T_SimpleCommand _ (w:_) [] -> True
         T_Assignment {} -> True
         T_Annotation _ _ w -> isAssignment w
-        _ -> False
+        otherwise -> False
 
 isOnlyRedirection t =
     case t of
@@ -300,15 +233,12 @@ isOnlyRedirection t =
         T_Annotation _ _ w -> isOnlyRedirection w
         T_Redirecting _ (_:_) c -> isOnlyRedirection c
         T_SimpleCommand _ [] [] -> True
-        _ -> False
+        otherwise -> False
 
 isFunction t = case t of T_Function {} -> True; _ -> False
 
-isBraceExpansion t = case t of T_BraceExpansion {} -> True; _ -> False
-
--- Get the lists of commands from tokens that contain them, such as
--- the body of while loops or branches of if statements.
-getCommandSequences :: Token -> [[Token]]
+-- Get the list of commands from tokens that contain them, such as
+-- the body of while loops and if statements.
 getCommandSequences t =
     case t of
         T_Script _ _ cmds -> [cmds]
@@ -319,118 +249,5 @@ getCommandSequences t =
         T_ForIn _ _ _ cmds -> [cmds]
         T_ForArithmetic _ _ _ _ cmds -> [cmds]
         T_IfExpression _ thens elses -> map snd thens ++ [elses]
-        T_Annotation _ _ t -> getCommandSequences t
-        _ -> []
+        otherwise -> []
 
--- Get a list of names of associative arrays
-getAssociativeArrays t =
-    nub . execWriter $ doAnalysis f t
-  where
-    f :: Token -> Writer [String] ()
-    f t@T_SimpleCommand {} = fromMaybe (return ()) $ do
-        name <- getCommandName t
-        let assocNames = ["declare","local","typeset"]
-        guard $ elem name assocNames
-        let flags = getAllFlags t
-        guard $ elem "A" $ map snd flags
-        let args = map fst . filter ((==) "" . snd) $ flags
-        let names = mapMaybe (getLiteralStringExt nameAssignments) args
-        return $ tell names
-    f _ = return ()
-
-    nameAssignments t =
-        case t of
-            T_Assignment _ _ name _ _ -> return name
-            _ -> Nothing
-
--- A Pseudoglob is a wildcard pattern used for checking if a match can succeed.
--- For example, [[ $(cmd).jpg == [a-z] ]] will give the patterns *.jpg and ?, which
--- can be proven never to match.
-data PseudoGlob = PGAny | PGMany | PGChar Char
-    deriving (Eq, Show)
-
--- Turn a word into a PG pattern, replacing all unknown/runtime values with
--- PGMany.
-wordToPseudoGlob :: Token -> Maybe [PseudoGlob]
-wordToPseudoGlob word =
-    simplifyPseudoGlob . concat <$> mapM f (getWordParts word)
-  where
-    f x = case x of
-        T_Literal _ s -> return $ map PGChar s
-        T_SingleQuoted _ s -> return $ map PGChar s
-
-        T_DollarBraced {} -> return [PGMany]
-        T_DollarExpansion {} -> return [PGMany]
-        T_Backticked {} -> return [PGMany]
-
-        T_Glob _ "?" -> return [PGAny]
-        T_Glob _ ('[':_)  -> return [PGAny]
-        T_Glob {} -> return [PGMany]
-
-        T_Extglob {} -> return [PGMany]
-
-        _ -> return [PGMany]
-
--- Turn a word into a PG pattern, but only if we can preserve
--- exact semantics.
-wordToExactPseudoGlob :: Token -> Maybe [PseudoGlob]
-wordToExactPseudoGlob word =
-    simplifyPseudoGlob . concat <$> mapM f (getWordParts word)
-  where
-    f x = case x of
-        T_Literal _ s -> return $ map PGChar s
-        T_SingleQuoted _ s -> return $ map PGChar s
-        T_Glob _ "?" -> return [PGAny]
-        T_Glob _ "*" -> return [PGMany]
-        _ -> fail "Unknown token type"
-
--- Reorder a PseudoGlob for more efficient matching, e.g.
--- f?*?**g -> f??*g
-simplifyPseudoGlob :: [PseudoGlob] -> [PseudoGlob]
-simplifyPseudoGlob = f
-  where
-    f [] = []
-    f (x@(PGChar _) : rest ) = x : f rest
-    f list =
-        let (anys, rest) = span (\x -> x == PGMany || x == PGAny) list in
-            order anys ++ f rest
-
-    order s = let (any, many) = partition (== PGAny) s in
-        any ++ take 1 many
-
--- Check whether the two patterns can ever overlap.
-pseudoGlobsCanOverlap :: [PseudoGlob] -> [PseudoGlob] -> Bool
-pseudoGlobsCanOverlap = matchable
-  where
-    matchable x@(xf:xs) y@(yf:ys) =
-        case (xf, yf) of
-            (PGMany, _) -> matchable x ys || matchable xs y
-            (_, PGMany) -> matchable x ys || matchable xs y
-            (PGAny, _) -> matchable xs ys
-            (_, PGAny) -> matchable xs ys
-            (_, _) -> xf == yf && matchable xs ys
-
-    matchable [] [] = True
-    matchable (PGMany : rest) [] = matchable rest []
-    matchable (_:_) [] = False
-    matchable [] r = matchable r []
-
--- Check whether the first pattern always overlaps the second.
-pseudoGlobIsSuperSetof :: [PseudoGlob] -> [PseudoGlob] -> Bool
-pseudoGlobIsSuperSetof = matchable
-  where
-    matchable x@(xf:xs) y@(yf:ys) =
-        case (xf, yf) of
-            (PGMany, PGMany) -> matchable x ys
-            (PGMany, _) -> matchable x ys || matchable xs y
-            (_, PGMany) -> False
-            (PGAny, _) -> matchable xs ys
-            (_, PGAny) -> False
-            (_, _) -> xf == yf && matchable xs ys
-
-    matchable [] [] = True
-    matchable (PGMany : rest) [] = matchable rest []
-    matchable _ _ = False
-
-wordsCanBeEqual x y = fromMaybe True $
-    liftM2 pseudoGlobsCanOverlap (wordToPseudoGlob x) (wordToPseudoGlob y)

ShellCheck/Analyzer.hs

@@ -23,23 +23,14 @@ import ShellCheck.Analytics
 import ShellCheck.AnalyzerLib
 import ShellCheck.Interface
 import Data.List
-import Data.Monoid
 import qualified ShellCheck.Checks.Commands
-import qualified ShellCheck.Checks.ShellSupport
 
 
 -- TODO: Clean up the cruft this is layered on
 analyzeScript :: AnalysisSpec -> AnalysisResult
 analyzeScript spec = AnalysisResult {
     arComments =
-        filterByAnnotation spec params . nub $
+        filterByAnnotation (asScript spec) . nub $
             runAnalytics spec
-            ++ runChecker params (checkers params)
+            ++ ShellCheck.Checks.Commands.runChecks spec
 }
-  where
-    params = makeParameters spec
-
-checkers params = mconcat $ map ($ params) [
-    ShellCheck.Checks.Commands.checker,
-    ShellCheck.Checks.ShellSupport.checker
-    ]

ShellCheck/AnalyzerLib.hs

@@ -29,7 +29,7 @@ import ShellCheck.Regex
 
 import Control.Arrow (first)
 import Control.Monad.Identity
-import Control.Monad.RWS
+import Control.Monad.Reader
 import Control.Monad.State
 import Control.Monad.Writer
 import Data.Char
@@ -40,50 +40,16 @@ import qualified Data.Map as Map
 import Test.QuickCheck.All (forAllProperties)
 import Test.QuickCheck.Test (quickCheckWithResult, stdArgs, maxSuccess)
 
-type Analysis = AnalyzerM ()
-type AnalyzerM a = RWS Parameters [TokenComment] Cache a
-nullCheck = const $ return ()
+type Analysis = ReaderT Parameters (Writer [TokenComment]) ()
 
 
-data Checker = Checker {
-    perScript :: Root -> Analysis,
-    perToken :: Token -> Analysis
-}
-
-runChecker :: Parameters -> Checker -> [TokenComment]
-runChecker params checker = notes
-    where
-        root = rootNode params
-        check = perScript checker `composeAnalyzers` (\(Root x) -> void $ doAnalysis (perToken checker) x)
-        notes = snd $ evalRWS (check $ Root root) params Cache
-
-instance Monoid Checker where
-    mempty = Checker {
-        perScript = nullCheck,
-        perToken = nullCheck
-        }
-    mappend x y = Checker {
-        perScript = perScript x `composeAnalyzers` perScript y,
-        perToken = perToken x `composeAnalyzers` perToken y
-        }
-
-
-composeAnalyzers :: (a -> Analysis) -> (a -> Analysis) -> a -> Analysis
-composeAnalyzers f g x = f x >> g x
-
 data Parameters = Parameters {
-    hasLastpipe :: Bool,           -- Whether this script has the 'lastpipe' option set/default.
-    hasSetE     :: Bool,           -- Whether this script has 'set -e' anywhere.
-    variableFlow :: [StackData],   -- A linear (bad) analysis of data flow
-    parentMap :: Map.Map Id Token, -- A map from Id to parent Token
-    shellType :: Shell,            -- The shell type, such as Bash or Ksh
-    shellTypeSpecified :: Bool,    -- True if shell type was forced via flags
-    rootNode :: Token              -- The root node of the AST
+    variableFlow :: [StackData],
+    parentMap :: Map.Map Id Token,
+    shellType :: Shell,
+    shellTypeSpecified :: Bool
     }
 
--- TODO: Cache results of common AST ops here
-data Cache = Cache {}
-
 data Scope = SubshellScope String | NoneScope deriving (Show, Eq)
 data StackData =
     StackScope Scope
@@ -96,12 +62,7 @@ data StackData =
 data DataType = DataString DataSource | DataArray DataSource
   deriving (Show)
 
-data DataSource =
-    SourceFrom [Token]
-    | SourceExternal
-    | SourceDeclaration
-    | SourceInteger
-    | SourceChecked
+data DataSource = SourceFrom [Token] | SourceExternal | SourceDeclaration | SourceInteger
   deriving (Show)
 
 data VariableState = Dead Token String | Alive deriving (Show)
@@ -109,7 +70,6 @@ data VariableState = Dead Token String | Alive deriving (Show)
 defaultSpec root = AnalysisSpec {
     asScript = root,
     asShellType = Nothing,
-    asCheckSourced = False,
     asExecutionMode = Executed
 }
 
@@ -117,19 +77,10 @@ pScript s =
   let
     pSpec = ParseSpec {
         psFilename = "script",
-        psScript = s,
-        psCheckSourced = False
+        psScript = s
     }
   in prRoot . runIdentity $ parseScript (mockedSystemInterface []) pSpec
 
--- For testing. If parsed, returns whether there are any comments
-producesComments :: Checker -> String -> Maybe Bool
-producesComments c s = do
-        root <- pScript s
-        let spec = defaultSpec root
-        let params = makeParameters spec
-        return . not . null $ runChecker params c
-
 makeComment :: Severity -> Id -> Code -> String -> TokenComment
 makeComment severity id code note =
     TokenComment id $ Comment severity code note
@@ -144,50 +95,14 @@ style id code str = addComment $ makeComment StyleC id code str
 
 makeParameters spec =
     let params = Parameters {
-        rootNode = root,
         shellType = fromMaybe (determineShell root) $ asShellType spec,
-        hasSetE = containsSetE root,
-        hasLastpipe =
-            case shellType params of
-                Bash -> containsLastpipe root
-                Dash -> False
-                Sh -> False
-                Ksh -> True,
-
         shellTypeSpecified = isJust $ asShellType spec,
         parentMap = getParentTree root,
-        variableFlow = getVariableFlow params root
+        variableFlow =
+            getVariableFlow (shellType params) (parentMap params) root
     } in params
   where root = asScript spec
 
-
--- Does this script mention 'set -e' anywhere?
--- Used as a hack to disable certain warnings.
-containsSetE root = isNothing $ doAnalysis (guard . not . isSetE) root
-  where
-    isSetE t =
-        case t of
-            T_Script _ str _ -> str `matches` re
-            T_SimpleCommand {}  ->
-                t `isUnqualifiedCommand` "set" &&
-                    ("errexit" `elem` oversimplify t ||
-                        "e" `elem` map snd (getAllFlags t))
-            _ -> False
-    re = mkRegex "[[:space:]]-[^-]*e"
-
--- Does this script mention 'shopt -s lastpipe' anywhere?
--- Also used as a hack.
-containsLastpipe root =
-        isNothing $ doAnalysis (guard . not . isShoptLastPipe) root
-    where
-        isShoptLastPipe t =
-            case t of
-                T_SimpleCommand {}  ->
-                    t `isUnqualifiedCommand` "shopt" &&
-                        ("lastpipe" `elem` oversimplify t)
-                _ -> False
-
-
 prop_determineShell0 = determineShell (fromJust $ pScript "#!/bin/sh") == Sh
 prop_determineShell1 = determineShell (fromJust $ pScript "#!/usr/bin/env ksh") == Ksh
 prop_determineShell2 = determineShell (fromJust $ pScript "") == Bash
@@ -197,7 +112,6 @@ prop_determineShell4 = determineShell (fromJust $ pScript
 prop_determineShell5 = determineShell (fromJust $ pScript
     "#shellcheck shell=sh\nfoo") == Sh
 prop_determineShell6 = determineShell (fromJust $ pScript "#! /bin/sh") == Sh
-prop_determineShell7 = determineShell (fromJust $ pScript "#! /bin/ash") == Dash
 determineShell t = fromMaybe Bash $ do
     shellString <- foldl mplus Nothing $ getCandidates t
     shellForExecutable shellString
@@ -207,26 +121,19 @@ determineShell t = fromMaybe Bash $ do
             (ShellOverride s) -> return s
             _ -> fail ""
     getCandidates :: Token -> [Maybe String]
-    getCandidates t@T_Script {} = [Just $ fromShebang t]
+    getCandidates t@(T_Script {}) = [Just $ fromShebang t]
     getCandidates (T_Annotation _ annotations s) =
         map forAnnotation annotations ++
            [Just $ fromShebang s]
-    fromShebang (T_Script _ s t) = executableFromShebang s
+    fromShebang (T_Script _ s t) = shellFor s
 
--- Given a string like "/bin/bash" or "/usr/bin/env dash",
--- return the shell basename like "bash" or "dash"
-executableFromShebang :: String -> String
-executableFromShebang = shellFor
-  where
     shellFor s | "/env " `isInfixOf` s = head (drop 1 (words s)++[""])
     shellFor s | ' ' `elem` s = shellFor $ takeWhile (/= ' ') s
     shellFor s = reverse . takeWhile (/= '/') . reverse $ s
 
 
+--- Context seeking
 
--- Given a root node, make a map from Id to parent Token.
--- This is used to populate parentMap in Parameters
-getParentTree :: Token -> Map.Map Id Token
 getParentTree t =
     snd . snd $ runState (doStackAnalysis pre post t) ([], Map.empty)
   where
@@ -236,24 +143,18 @@ getParentTree t =
         case rest of [] -> put (rest, map)
                      (x:_) -> put (rest, Map.insert (getId t) x map)
 
--- Given a root node, make a map from Id to Token
-getTokenMap :: Token -> Map.Map Id Token
 getTokenMap t =
     execState (doAnalysis f t) Map.empty
   where
     f t = modify (Map.insert (getId t) t)
 
 
--- Is this token in a quoting free context? (i.e. would variable expansion split)
--- True:  Assignments, [[ .. ]], here docs, already in double quotes
--- False: Regular words
-isStrictlyQuoteFree = isQuoteFreeNode True
-
--- Like above, but also allow some cases where splitting may be desired.
--- True:  Like above + for loops
--- False: Like above
+-- Is this node self quoting for a regular element?
 isQuoteFree = isQuoteFreeNode False
 
+-- Is this node striclty self quoting, for array expansions
+isStrictlyQuoteFree = isQuoteFreeNode True
+
 
 isQuoteFreeNode strict tree t =
     (isQuoteFreeElement t == Just True) ||
@@ -269,13 +170,16 @@ isQuoteFreeNode strict tree t =
     -- Are any subnodes inherently self-quoting?
     isQuoteFreeContext t =
         case t of
-            TC_Nullary _ DoubleBracket _ -> return True
+            TC_Noary _ DoubleBracket _ -> return True
             TC_Unary _ DoubleBracket _ _ -> return True
             TC_Binary _ DoubleBracket _ _ _ -> return True
             TA_Sequence {} -> return True
             T_Arithmetic {} -> return True
             T_Assignment {} -> return True
-            T_Redirecting {} -> return False
+            T_Redirecting {} -> return $
+                if strict then False else
+                    -- Not true, just a hack to prevent warning about non-expansion refs
+                    any (isCommand t) ["local", "declare", "typeset", "export", "trap", "readonly"]
             T_DoubleQuoted _ _ -> return True
             T_DollarDoubleQuoted _ _ -> return True
             T_CaseExpression {} -> return True
@@ -286,9 +190,6 @@ isQuoteFreeNode strict tree t =
             T_SelectIn {} -> return (not strict)
             _ -> Nothing
 
--- Check if a token is a parameter to a certain command by name:
--- Example: isParamTo (parentMap params) "sed" t
-isParamTo :: Map.Map Id Token -> String -> Token -> Bool
 isParamTo tree cmd =
     go
   where
@@ -304,23 +205,12 @@ isParamTo tree cmd =
             T_Redirecting {} -> isCommand t cmd
             _ -> False
 
--- Get the parent command (T_Redirecting) of a Token, if any.
-getClosestCommand :: Map.Map Id Token -> Token -> Maybe Token
 getClosestCommand tree t =
-    findFirst findCommand $ getPath tree t
+    msum . map getCommand $ getPath tree t
   where
-    findCommand t =
-        case t of
-            T_Redirecting {} -> return True
-            T_Script {} -> return False
-            _ -> Nothing
+    getCommand t@(T_Redirecting {}) = return t
+    getCommand _ = Nothing
 
--- Like above, if koala_man knew Haskell when starting this project.
-getClosestCommandM t = do
-    tree <- asks parentMap
-    return $ getClosestCommand tree t
-
--- Is the token used as a command name (the first word in a T_SimpleCommand)?
 usedAsCommandName tree token = go (getId token) (tail $ getPath tree token)
   where
     go currentId (T_NormalWord id [word]:rest)
@@ -331,18 +221,12 @@ usedAsCommandName tree token = go (getId token) (tail $ getPath tree token)
         | currentId == getId word = True
     go _ _ = False
 
--- A list of the element and all its parents up to the root node.
+-- A list of the element and all its parents
 getPath tree t = t :
     case Map.lookup (getId t) tree of
         Nothing -> []
         Just parent -> getPath tree parent
 
--- Version of the above taking the map from the current context
--- Todo: give this the name "getPath"
-getPathM t = do
-    map <- asks parentMap
-    return $ getPath map t
-
 isParentOf tree parent child =
     elem (getId parent) . map getId $ getPath tree child
 
@@ -352,18 +236,6 @@ pathTo t = do
     parents <- reader parentMap
     return $ getPath parents t
 
--- Find the first match in a list where the predicate is Just True.
--- Stops if it's Just False and ignores Nothing.
-findFirst :: (a -> Maybe Bool) -> [a] -> Maybe a
-findFirst p l =
-    case l of
-        [] -> Nothing
-        (x:xs) ->
-            case p x of
-                Just True -> return x
-                Just False -> Nothing
-                Nothing -> findFirst p xs
-
 -- Check whether a word is entirely output from a single command
 tokenIsJustCommandOutput t = case t of
     T_NormalWord id [T_DollarExpansion _ cmds] -> check cmds
@@ -376,29 +248,29 @@ tokenIsJustCommandOutput t = case t of
     check _ = False
 
 -- TODO: Replace this with a proper Control Flow Graph
-getVariableFlow params t =
+getVariableFlow shell parents t =
     let (_, stack) = runState (doStackAnalysis startScope endScope t) []
     in reverse stack
   where
     startScope t =
-        let scopeType = leadType params t
+        let scopeType = leadType shell parents t
         in do
             when (scopeType /= NoneScope) $ modify (StackScope scopeType:)
             when (assignFirst t) $ setWritten t
 
     endScope t =
-        let scopeType = leadType params t
+        let scopeType = leadType shell parents t
         in do
             setRead t
             unless (assignFirst t) $ setWritten t
             when (scopeType /= NoneScope) $ modify (StackScopeEnd:)
 
-    assignFirst T_ForIn {} = True
-    assignFirst T_SelectIn {} = True
+    assignFirst (T_ForIn {}) = True
+    assignFirst (T_SelectIn {}) = True
     assignFirst _ = False
 
     setRead t =
-        let read    = getReferencedVariables (parentMap params) t
+        let read    = getReferencedVariables parents t
         in mapM_ (\v -> modify (Reference v:)) read
 
     setWritten t =
@@ -406,7 +278,7 @@ getVariableFlow params t =
         in mapM_ (\v -> modify (Assignment v:)) written
 
 
-leadType params t =
+leadType shell parents t =
     case t of
         T_DollarExpansion _ _  -> SubshellScope "$(..) expansion"
         T_Backticked _ _  -> SubshellScope "`..` expansion"
@@ -420,7 +292,7 @@ leadType params t =
         _ -> NoneScope
   where
     parentPipeline = do
-        parent <- Map.lookup (getId t) (parentMap params)
+        parent <- Map.lookup (getId t) parents
         case parent of
             T_Pipeline {} -> return parent
             _ -> Nothing
@@ -429,10 +301,17 @@ leadType params t =
         (T_Pipeline _ _ list) <- parentPipeline
         if length list <= 1
             then return False
-            else if not $ hasLastpipe params
+            else if lastCreatesSubshell
                 then return True
                 else return . not $ (getId . head $ reverse list) == getId t
 
+    lastCreatesSubshell =
+        case shell of
+            Bash -> True
+            Dash -> True
+            Sh -> True
+            Ksh -> False
+
 getModifiedVariables t =
     case t of
         T_SimpleCommand _ vars [] ->
@@ -441,7 +320,7 @@ getModifiedVariables t =
                                     [(x, x, name, dataTypeFrom DataString w)]
                                 _ -> []
                       ) vars
-        c@T_SimpleCommand {} ->
+        c@(T_SimpleCommand {}) ->
             getModifiedVariableCommand c
 
         TA_Unary _ "++|" var -> maybeToList $ do
@@ -455,24 +334,6 @@ getModifiedVariables t =
             name <- getLiteralString lhs
             return (t, t, name, DataString $ SourceFrom [rhs])
 
-        -- Count [[ -v foo ]] as an "assignment".
-        -- This is to prevent [ -v foo ] being unassigned or unused.
-        TC_Unary id _ "-v" token -> maybeToList $ do
-            str <- fmap (takeWhile (/= '[')) $ -- Quoted index
-                    flip getLiteralStringExt token $ \x ->
-                case x of
-                    T_Glob _ s -> return s -- Unquoted index
-                    _ -> Nothing
-
-            guard . not . null $ str
-            return (t, token, str, DataString $ SourceChecked)
-
-        T_DollarBraced _ l -> maybeToList $ do
-            let string = bracedString t
-            let modifier = getBracedModifier string
-            guard $ ":=" `isPrefixOf` modifier
-            return (t, t, getBracedReference string, DataString $ SourceFrom [l])
-
         t@(T_FdRedirect _ ('{':var) op) -> -- {foo}>&2 modifies foo
             [(t, t, takeWhile (/= '}') var, DataString SourceInteger) | not $ isClosingFileOp op]
 
@@ -480,15 +341,14 @@ getModifiedVariables t =
             [(t, t, fromMaybe "COPROC" name, DataArray SourceInteger)]
 
         --Points to 'for' rather than variable
-        T_ForIn id str [] _ -> [(t, t, str, DataString SourceExternal)]
         T_ForIn id str words _ -> [(t, t, str, DataString $ SourceFrom words)]
         T_SelectIn id str words _ -> [(t, t, str, DataString $ SourceFrom words)]
         _ -> []
 
 isClosingFileOp op =
     case op of
-        T_IoDuplicate _ (T_GREATAND _) "-" -> True
-        T_IoDuplicate _ (T_LESSAND  _) "-" -> True
+        T_IoFile _ (T_GREATAND _) (T_NormalWord _ [T_Literal _ "-"]) -> True
+        T_IoFile _ (T_LESSAND  _) (T_NormalWord _ [T_Literal _ "-"]) -> True
         _ -> False
 
 
@@ -501,10 +361,7 @@ getReferencedVariableCommand base@(T_SimpleCommand _ _ (T_NormalWord _ (T_Litera
         "declare" -> if any (`elem` flags) ["x", "p"]
             then concatMap getReference rest
             else []
-        "readonly" ->
-            if any (`elem` flags) ["f", "p"]
-            then []
-            else concatMap getReference rest
+        "readonly" -> concatMap getReference rest
         "trap" ->
             case rest of
                 head:_ -> map (\x -> (head, head, x)) $ getVariablesFromLiteralToken head
@@ -538,10 +395,7 @@ getModifiedVariableCommand base@(T_SimpleCommand _ _ (T_NormalWord _ (T_Literal
         "typeset" -> declaredVars
 
         "local" -> concatMap getModifierParamString rest
-        "readonly" ->
-            if any (`elem` flags) ["f", "p"]
-            then []
-            else concatMap getModifierParamString rest
+        "readonly" -> concatMap getModifierParamString rest
         "set" -> maybeToList $ do
             params <- getSetParams rest
             return (base, base, "@", DataString $ SourceFrom params)
@@ -575,7 +429,7 @@ getModifiedVariableCommand base@(T_SimpleCommand _ _ (T_NormalWord _ (T_Literal
 
     getModifierParam def t@(T_Assignment _ _ name _ value) =
         [(base, t, name, dataTypeFrom def value)]
-    getModifierParam def t@T_NormalWord {} = maybeToList $ do
+    getModifierParam def t@(T_NormalWord {}) = maybeToList $ do
         name <- getLiteralString t
         guard $ isVariableName name
         return (base, t, name, def SourceDeclaration)
@@ -620,20 +474,11 @@ getIndexReferences s = fromMaybe [] $ do
   where
     re = mkRegex "(\\[.*\\])"
 
-getOffsetReferences mods = fromMaybe [] $ do
-    match <- matchRegex re mods
-    offsets <- match !!! 0
-    return $ matchAllStrings variableNameRegex offsets
-  where
-    re = mkRegex "^ *:([^-=?+].*)"
-
 getReferencedVariables parents t =
     case t of
         T_DollarBraced id l -> let str = bracedString t in
             (t, t, getBracedReference str) :
-                map (\x -> (l, l, x)) (
-                    getIndexReferences str
-                    ++ getOffsetReferences (getBracedModifier str))
+                map (\x -> (l, l, x)) (getIndexReferences str)
         TA_Expansion id _ ->
             if isArithmeticAssignment t
             then []
@@ -663,10 +508,8 @@ getReferencedVariables parents t =
                 getVariablesFromLiteralToken word
         else []
 
-    literalizer t = case t of
-        TA_Index {} -> return ""  -- x[0] becomes a reference of x
-        T_Glob _ s -> return s    -- Also when parsed as globs
-        _ -> Nothing
+    literalizer (TA_Index {}) = return ""  -- x[0] becomes a reference of x
+    literalizer _ = Nothing
 
     getIfReference context token = maybeToList $ do
             str <- getLiteralStringExt literalizer token
@@ -677,7 +520,7 @@ getReferencedVariables parents t =
     isDereferencing = (`elem` ["-eq", "-ne", "-lt", "-le", "-gt", "-ge"])
 
     isArithmeticAssignment t = case getPath parents t of
-        this: TA_Assignment _ "=" lhs _ :_ -> lhs == t
+        this: TA_Assignment _ "=" _ _ :_ -> True
         _ -> False
 
 dataTypeFrom defaultType v = (case v of T_Array {} -> DataArray; _ -> defaultType) $ SourceFrom [v]
@@ -685,20 +528,13 @@ dataTypeFrom defaultType v = (case v of T_Array {} -> DataArray; _ -> defaultTyp
 
 --- Command specific checks
 
--- Compare a command to a string: t `isCommand` "sed" (also matches /usr/bin/sed)
 isCommand token str = isCommandMatch token (\cmd -> cmd  == str || ('/' : str) `isSuffixOf` cmd)
-
--- Compare a command to a literal. Like above, but checks full path.
 isUnqualifiedCommand token str = isCommandMatch token (== str)
 
 isCommandMatch token matcher = fromMaybe False $ do
     cmd <- getCommandName token
     return $ matcher cmd
 
--- Does this regex look like it was intended as a glob?
--- True:  *foo*
--- False: .*foo.*
-isConfusedGlobRegex :: String -> Bool
 isConfusedGlobRegex ('*':_) = True
 isConfusedGlobRegex [x,'*'] | x /= '\\' = True
 isConfusedGlobRegex _ = False
@@ -725,7 +561,6 @@ getVariablesFromLiteral string =
   where
     variableRegex = mkRegex "\\$\\{?([A-Za-z0-9_]+)"
 
--- Get the variable name from an expansion like ${var:-foo}
 prop_getBracedReference1 = getBracedReference "foo" == "foo"
 prop_getBracedReference2 = getBracedReference "#foo" == "foo"
 prop_getBracedReference3 = getBracedReference "#" == "#"
@@ -738,7 +573,6 @@ prop_getBracedReference9 = getBracedReference "foo:-bar" == "foo"
 prop_getBracedReference10= getBracedReference "foo: -1" == "foo"
 prop_getBracedReference11= getBracedReference "!os*" == ""
 prop_getBracedReference12= getBracedReference "!os?bar**" == ""
-prop_getBracedReference13= getBracedReference "foo[bar]" == "foo"
 getBracedReference s = fromMaybe s $
     nameExpansion s `mplus` takeName noPrefix `mplus` getSpecial noPrefix `mplus` getSpecial s
   where
@@ -761,52 +595,24 @@ getBracedReference s = fromMaybe s $
         return ""
     nameExpansion _ = Nothing
 
-prop_getBracedModifier1 = getBracedModifier "foo:bar:baz" == ":bar:baz"
-prop_getBracedModifier2 = getBracedModifier "!var:-foo" == ":-foo"
-prop_getBracedModifier3 = getBracedModifier "foo[bar]" == "[bar]"
-getBracedModifier s = fromMaybe "" . listToMaybe $ do
-    let var = getBracedReference s
-    a <- dropModifier s
-    dropPrefix var a
-  where
-    dropPrefix [] t = return t
-    dropPrefix (a:b) (c:d) | a == c = dropPrefix b d
-    dropPrefix _ _ = []
 
-    dropModifier (c:rest) | c `elem` "#!" = [rest, c:rest]
-    dropModifier x = [x]
-
--- Useful generic functions.
-
--- Run an action in a Maybe (or do nothing).
--- Example:
--- potentially $ do
---   s <- getLiteralString cmd
---   guard $ s `elem` ["--recursive", "-r"]
---   return $ warn .. "Something something recursive"
+-- Useful generic functions
 potentially :: Monad m => Maybe (m ()) -> m ()
 potentially = fromMaybe (return ())
 
--- Get element 0 or a default. Like `head` but safe.
 headOrDefault _ (a:_) = a
 headOrDefault def _ = def
 
---- Get element n of a list, or Nothing. Like `!!` but safe.
 (!!!) list i =
     case drop i list of
         [] -> Nothing
         (r:_) -> Just r
 
--- Run a command if the shell is in the given list
-whenShell l c = do
-    shell <- asks shellType
-    when (shell `elem` l ) c
 
 
-filterByAnnotation asSpec params =
+filterByAnnotation token =
     filter (not . shouldIgnore)
   where
-    token = asScript asSpec
     idFor (TokenComment id _) = id
     shouldIgnore note =
         any (shouldIgnoreFor (getCode note)) $
@@ -816,28 +622,11 @@ filterByAnnotation asSpec params =
       where
         hasNum (DisableComment ts) = num == ts
         hasNum _ = False
-    shouldIgnoreFor _ T_Include {} = not $ asCheckSourced asSpec
+    shouldIgnoreFor _ (T_Include {}) = True -- Ignore included files
     shouldIgnoreFor _ _ = False
-    parents = parentMap params
+    parents = getParentTree token
     getCode (TokenComment _ (Comment _ c _)) = c
 
--- Is this a ${#anything}, to get string length or array count?
-isCountingReference (T_DollarBraced id token) =
-    case concat $ oversimplify token of
-        '#':_ -> True
-        _ -> False
-isCountingReference _ = False
 
--- FIXME: doesn't handle ${a:+$var} vs ${a:+"$var"}
-isQuotedAlternativeReference t =
-    case t of
-        T_DollarBraced _ _ ->
-            getBracedModifier (bracedString t) `matches` re
-        _ -> False
-  where
-    re = mkRegex "(^|\\]):?\\+"
-
-
-
-return []
+return [] 
 runTests =  $( [| $(forAllProperties) (quickCheckWithResult (stdArgs { maxSuccess = 1 }) ) |])

ShellCheck/Checker.hs

@@ -39,7 +39,7 @@ import Test.QuickCheck.All
 
 tokenToPosition map (TokenComment id c) = fromMaybe fail $ do
     position <- Map.lookup id map
-    return $ PositionedComment position position c
+    return $ PositionedComment position c
   where
     fail = error "Internal shellcheck error: id doesn't exist. Please report!"
 
@@ -54,8 +54,7 @@ checkScript sys spec = do
     checkScript contents = do
         result <- parseScript sys ParseSpec {
             psFilename = csFilename spec,
-            psScript = contents,
-            psCheckSourced = csCheckSourced spec
+            psScript = contents
         }
         let parseMessages = prComments result
         let analysisMessages =
@@ -66,19 +65,18 @@ checkScript sys spec = do
         return . nub . sortMessages . filter shouldInclude $
             (parseMessages ++ map translator analysisMessages)
 
-    shouldInclude (PositionedComment _ _ (Comment _ code _)) =
+    shouldInclude (PositionedComment _ (Comment _ code _)) =
         code `notElem` csExcludedWarnings spec
 
     sortMessages = sortBy (comparing order)
-    order (PositionedComment pos _ (Comment severity code message)) =
+    order (PositionedComment pos (Comment severity code message)) =
         (posFile pos, posLine pos, posColumn pos, severity, code, message)
-    getPosition (PositionedComment pos _ _) = pos
+    getPosition (PositionedComment pos _) = pos
 
     analysisSpec root =
         AnalysisSpec {
             asScript = root,
             asShellType = csShellTypeOverride spec,
-            asCheckSourced = csCheckSourced spec,
             asExecutionMode = Executed
          }
 
@@ -86,25 +84,17 @@ getErrors sys spec =
     sort . map getCode . crComments $
         runIdentity (checkScript sys spec)
   where
-    getCode (PositionedComment _ _ (Comment _ code _)) = code
+    getCode (PositionedComment _ (Comment _ code _)) = code
 
 check = checkWithIncludes []
 
-checkWithSpec includes =
-    getErrors (mockedSystemInterface includes)
-
 checkWithIncludes includes src =
-    checkWithSpec includes emptyCheckSpec {
-        csScript = src,
-        csExcludedWarnings = [2148]
-    }
-
-checkRecursive includes src =
-    checkWithSpec includes emptyCheckSpec {
-        csScript = src,
-        csExcludedWarnings = [2148],
-        csCheckSourced = True
-    }
+    getErrors
+        (mockedSystemInterface includes)
+        emptyCheckSpec {
+            csScript = src,
+            csExcludedWarnings = [2148]
+        }
 
 prop_findsParseIssue = check "echo \"$12\"" == [1037]
 
@@ -163,36 +153,10 @@ prop_cantSourceDynamic2 =
 prop_canSourceDynamicWhenRedirected =
     null $ checkWithIncludes [("lib", "")] "#shellcheck source=lib\n. \"$1\""
 
-prop_recursiveAnalysis =
-    [2086] == checkRecursive [("lib", "echo $1")] "source lib"
-
-prop_recursiveParsing =
-    [1037] == checkRecursive [("lib", "echo \"$10\"")] "source lib"
-
 prop_sourceDirectiveDoesntFollowFile =
     null $ checkWithIncludes
                 [("foo", "source bar"), ("bar", "baz=3")]
                 "#shellcheck source=foo\n. \"$1\"; echo \"$baz\""
 
-prop_filewideAnnotationBase = [2086] == check "#!/bin/sh\necho $1"
-prop_filewideAnnotation1 = null $
-    check "#!/bin/sh\n# shellcheck disable=2086\necho $1"
-prop_filewideAnnotation2 = null $
-    check "#!/bin/sh\n# shellcheck disable=2086\ntrue\necho $1"
-prop_filewideAnnotation3 = null $
-    check "#!/bin/sh\n#unerlated\n# shellcheck disable=2086\ntrue\necho $1"
-prop_filewideAnnotation4 = null $
-    check "#!/bin/sh\n# shellcheck disable=2086\n#unrelated\ntrue\necho $1"
-prop_filewideAnnotation5 = null $
-    check "#!/bin/sh\n\n\n\n#shellcheck disable=2086\ntrue\necho $1"
-prop_filewideAnnotation6 = null $
-    check "#shellcheck shell=sh\n#unrelated\n#shellcheck disable=2086\ntrue\necho $1"
-prop_filewideAnnotation7 = null $
-    check "#!/bin/sh\n# shellcheck disable=2086\n#unrelated\ntrue\necho $1"
-
-prop_filewideAnnotationBase2 = [2086, 2181] == check "true\n[ $? == 0 ] && echo $1"
-prop_filewideAnnotation8 = null $
-    check "# Disable $? warning\n#shellcheck disable=SC2181\n# Disable quoting warning\n#shellcheck disable=2086\ntrue\n[ $? == 0 ] && echo $1"
-
 return []
 runTests = $quickCheckAll

ShellCheck/Checks/Commands.hs

@@ -21,7 +21,7 @@
 {-# LANGUAGE FlexibleContexts #-}
 
 -- This module contains checks that examine specific commands by name.
-module ShellCheck.Checks.Commands (checker
+module ShellCheck.Checks.Commands (runChecks
     , ShellCheck.Checks.Commands.runTests
 ) where
 
@@ -34,11 +34,12 @@ import ShellCheck.Parser
 import ShellCheck.Regex
 
 import Control.Monad
-import Control.Monad.RWS
+import Control.Monad.Reader
+import Control.Monad.Writer
 import Data.Char
 import Data.List
 import Data.Maybe
-import qualified Data.Map.Strict as Map
+import qualified Data.Map as Map
 import Test.QuickCheck.All (forAllProperties)
 import Test.QuickCheck.Test (quickCheckWithResult, stdArgs, maxSuccess)
 
@@ -48,10 +49,22 @@ data CommandName = Exactly String | Basename String
 data CommandCheck =
     CommandCheck CommandName (Token -> Analysis)
 
+nullCheck :: Token -> Analysis
+nullCheck _ = return ()
+
 
 verify :: CommandCheck -> String -> Bool
-verify f s = producesComments (getChecker [f]) s == Just True
-verifyNot f s = producesComments (getChecker [f]) s == Just False
+verify f s = producesComments f s == Just True
+verifyNot f s = producesComments f s == Just False
+
+producesComments :: CommandCheck -> String -> Maybe Bool
+producesComments f s = do
+        root <- pScript s
+        return . not . null $ runList (defaultSpec root) [f]
+
+composeChecks f g t = do
+    f t
+    g t
 
 arguments (T_SimpleCommand _ _ (cmd:args)) = args
 
@@ -77,24 +90,13 @@ commandChecks = [
     ,checkExportedExpansions
     ,checkAliasesUsesArgs
     ,checkAliasesExpandEarly
-    ,checkUnsetGlobs
-    ,checkFindWithoutPath
-    ,checkTimeParameters
-    ,checkTimedCommand
-    ,checkLocalScope
-    ,checkDeprecatedTempfile
-    ,checkDeprecatedEgrep
-    ,checkDeprecatedFgrep
-    ,checkWhileGetoptsCase
-    ,checkCatastrophicRm
-    ,checkLetUsage
     ]
 
 buildCommandMap :: [CommandCheck] -> Map.Map CommandName (Token -> Analysis)
 buildCommandMap = foldl' addCheck Map.empty
   where
     addCheck map (CommandCheck name function) =
-        Map.insertWith composeAnalyzers name function map
+        Map.insertWith' composeChecks name function map
 
 
 checkCommand :: Map.Map CommandName (Token -> Analysis) -> Token -> Analysis
@@ -112,17 +114,15 @@ checkCommand map t@(T_SimpleCommand id _ (cmd:rest)) = fromMaybe (return ()) $ d
     basename = reverse . takeWhile (/= '/') . reverse
 checkCommand _ _ = return ()
 
-getChecker :: [CommandCheck] -> Checker
-getChecker list = Checker {
-    perScript = const $ return (),
-    perToken = checkCommand map
-    }
-  where
-    map = buildCommandMap list
+runList spec list = notes
+    where
+        root = asScript spec
+        params = makeParameters spec
+        notes = execWriter $ runReaderT (doAnalysis (checkCommand map) root) params
+        map = buildCommandMap list
 
+runChecks spec = runList spec commandChecks
 
-checker :: Parameters -> Checker
-checker params = getChecker commandChecks
 
 prop_checkTr1 = verify checkTr "tr [a-f] [A-F]"
 prop_checkTr2 = verify checkTr "tr 'a-z' 'A-Z'"
@@ -150,7 +150,7 @@ checkTr = CommandCheck (Basename "tr") (mapM_ f . arguments)
             info (getId word) 2020 "tr replaces sets of chars, not words (mentioned due to duplicates)."
           unless ("[:" `isPrefixOf` s) $
             when ("[" `isPrefixOf` s && "]" `isSuffixOf` s && (length s > 2) && ('*' `notElem` s)) $
-              info (getId word) 2021 "Don't use [] around classes in tr, it replaces literal square brackets."
+              info (getId word) 2021 "Don't use [] around ranges in tr, it replaces literal square brackets."
         Nothing -> return ()
 
     duplicated s =
@@ -197,40 +197,23 @@ prop_checkGrepRe8 = verify checkGrepRe "ls | grep foo*.jpg"
 prop_checkGrepRe9 = verifyNot checkGrepRe "grep '[0-9]*' file"
 prop_checkGrepRe10= verifyNot checkGrepRe "grep '^aa*' file"
 prop_checkGrepRe11= verifyNot checkGrepRe "grep --include=*.png foo"
-prop_checkGrepRe12= verifyNot checkGrepRe "grep -F 'Foo*' file"
-prop_checkGrepRe13= verifyNot checkGrepRe "grep -- -foo bar*"
-prop_checkGrepRe14= verifyNot checkGrepRe "grep -e -foo bar*"
-prop_checkGrepRe15= verifyNot checkGrepRe "grep --regex -foo bar*"
 
-checkGrepRe = CommandCheck (Basename "grep") check where
-    check cmd = f cmd (arguments cmd)
+checkGrepRe = CommandCheck (Basename "grep") (f . arguments) where
     -- --regex=*(extglob) doesn't work. Fixme?
     skippable (Just s) = not ("--regex=" `isPrefixOf` s) && "-" `isPrefixOf` s
     skippable _ = False
-    f _ [] = return ()
-    f cmd (x:r) =
-        let str = getLiteralStringExt (const $ return "_") x
-        in
-            if str `elem` [Just "--", Just "-e", Just "--regex"]
-            then checkRE cmd r -- Regex is *after* this
-            else
-                if skippable str
-                then f cmd r           -- Regex is elsewhere
-                else checkRE cmd (x:r) -- Regex is this
-
-    checkRE _ [] = return ()
-    checkRE cmd (re:_) = do
+    f [] = return ()
+    f (x:r) | skippable (getLiteralStringExt (const $ return "_") x) = f r
+    f (re:_) = do
         when (isGlob re) $
             warn (getId re) 2062 "Quote the grep pattern so the shell won't interpret it."
-
-        unless (cmd `hasFlag` "F") $ do
-            let string = concat $ oversimplify re
-            if isConfusedGlobRegex string then
-                warn (getId re) 2063 "Grep uses regex, but this looks like a glob."
-              else potentially $ do
-                char <- getSuspiciousRegexWildcard string
-                return $ info (getId re) 2022 $
-                    "Note that unlike globs, " ++ [char] ++ "* here matches '" ++ [char, char, char] ++ "' but not '" ++ wordStartingWith char ++ "'."
+        let string = concat $ oversimplify re
+        if isConfusedGlobRegex string then
+            warn (getId re) 2063 "Grep uses regex, but this looks like a glob."
+          else potentially $ do
+            char <- getSuspiciousRegexWildcard string
+            return $ info (getId re) 2022 $
+                "Note that unlike globs, " ++ [char] ++ "* here matches '" ++ [char, char, char] ++ "' but not '" ++ wordStartingWith char ++ "'."
 
     wordStartingWith c =
         head . filter ([c] `isPrefixOf`) $ candidates
@@ -359,7 +342,7 @@ checkInjectableFindSh = CommandCheck (Basename "find") (check . arguments)
 
     pattern = [
         (`elem` ["-exec", "-execdir"]),
-        (`elem` ["sh", "bash", "dash", "ksh"]),
+        (`elem` ["sh", "bash", "ksh"]),
         (== "-c")
         ]
     action (id, arg) =
@@ -379,7 +362,7 @@ checkFindActionPrecedence = CommandCheck (Basename "find") (f . arguments)
         then warnFor (list !! (length pattern - 1))
         else f rest
     isMatch = isParam [ "-name", "-regex", "-iname", "-iregex", "-wholename", "-iwholename" ]
-    isAction = isParam [ "-exec", "-execdir", "-delete", "-print", "-print0", "-fls", "-fprint", "-fprint0", "-fprintf", "-ls", "-ok", "-okdir", "-printf" ]
+    isAction = isParam [ "-exec", "-execdir", "-delete", "-print", "-print0" ]
     isParam strs t = fromMaybe False $ do
         param <- getLiteralString t
         return $ param `elem` strs
@@ -401,26 +384,17 @@ prop_checkMkdirDashPM11 = verifyNot checkMkdirDashPM "mkdir --parents a/b"
 prop_checkMkdirDashPM12 = verifyNot checkMkdirDashPM "mkdir --mode=0755 a/b"
 prop_checkMkdirDashPM13 = verifyNot checkMkdirDashPM "mkdir_func -pm 0755 a/b"
 prop_checkMkdirDashPM14 = verifyNot checkMkdirDashPM "mkdir -p -m 0755 singlelevel"
-prop_checkMkdirDashPM15 = verifyNot checkMkdirDashPM "mkdir -p -m 0755 ../bin"
-prop_checkMkdirDashPM16 = verify checkMkdirDashPM "mkdir -p -m 0755 ../bin/laden"
-prop_checkMkdirDashPM17 = verifyNot checkMkdirDashPM "mkdir -p -m 0755 ./bin"
-prop_checkMkdirDashPM18 = verify checkMkdirDashPM "mkdir -p -m 0755 ./bin/laden"
-prop_checkMkdirDashPM19 = verifyNot checkMkdirDashPM "mkdir -p -m 0755 ./../bin"
-prop_checkMkdirDashPM20 = verifyNot checkMkdirDashPM "mkdir -p -m 0755 .././bin"
-prop_checkMkdirDashPM21 = verifyNot checkMkdirDashPM "mkdir -p -m 0755 ../../bin"
 checkMkdirDashPM = CommandCheck (Basename "mkdir") check
   where
     check t = potentially $ do
         let flags = getAllFlags t
         dashP <- find ((\f -> f == "p" || f == "parents") . snd) flags
         dashM <- find ((\f -> f == "m" || f == "mode") . snd) flags
-        -- mkdir -pm 0700 dir  is fine, so is ../dir, but dir/subdir is not.
-        guard $ any couldHaveSubdirs (drop 1 $ arguments t)
+        guard $ any couldHaveSubdirs (drop 1 $ arguments t) -- mkdir -pm 0700 dir  is fine, but dir/subdir is not.
         return $ warn (getId $ fst dashM) 2174 "When used with -p, -m only applies to the deepest directory."
     couldHaveSubdirs t = fromMaybe True $ do
         name <- getLiteralString t
-        return $ '/' `elem` name && not (name `matches` re)
-    re = mkRegex "^(\\.\\.?\\/)+[^/]+$"
+        return $ '/' `elem` name
 
 
 prop_checkNonportableSignals1 = verify checkNonportableSignals "trap f 8"
@@ -429,13 +403,9 @@ prop_checkNonportableSignals3 = verifyNot checkNonportableSignals "trap f 14"
 prop_checkNonportableSignals4 = verify checkNonportableSignals "trap f SIGKILL"
 prop_checkNonportableSignals5 = verify checkNonportableSignals "trap f 9"
 prop_checkNonportableSignals6 = verify checkNonportableSignals "trap f stop"
-prop_checkNonportableSignals7 = verifyNot checkNonportableSignals "trap 'stop' int"
 checkNonportableSignals = CommandCheck (Exactly "trap") (f . arguments)
   where
-    f args = case args of
-        first:rest -> unless (isFlag first) $ mapM_ check rest
-        _ -> return ()
-
+    f = mapM_ check
     check param = potentially $ do
         str <- getLiteralString param
         let id = getId param
@@ -500,51 +470,16 @@ prop_checkPrintfVar1 = verify checkPrintfVar "printf \"Lol: $s\""
 prop_checkPrintfVar2 = verifyNot checkPrintfVar "printf 'Lol: $s'"
 prop_checkPrintfVar3 = verify checkPrintfVar "printf -v cow $(cmd)"
 prop_checkPrintfVar4 = verifyNot checkPrintfVar "printf \"%${count}s\" var"
-prop_checkPrintfVar5 = verify checkPrintfVar "printf '%s %s %s' foo bar"
-prop_checkPrintfVar6 = verify checkPrintfVar "printf foo bar baz"
-prop_checkPrintfVar7 = verify checkPrintfVar "printf -- foo bar baz"
-prop_checkPrintfVar8 = verifyNot checkPrintfVar "printf '%s %s %s' \"${var[@]}\""
-prop_checkPrintfVar9 = verifyNot checkPrintfVar "printf '%s %s %s\\n' *.png"
-prop_checkPrintfVar10= verifyNot checkPrintfVar "printf '%s %s %s' foo bar baz"
-prop_checkPrintfVar11= verifyNot checkPrintfVar "printf '%(%s%s)T' -1"
 checkPrintfVar = CommandCheck (Exactly "printf") (f . arguments) where
-    f (doubledash:rest) | getLiteralString doubledash == Just "--" = f rest
     f (dashv:var:rest) | getLiteralString dashv == Just "-v" = f rest
-    f (format:params) = check format params
+    f (format:params) = check format
     f _ = return ()
-
-    countFormats string =
-        case string of
-            '%':'%':rest -> countFormats rest
-            '%':'(':rest -> 1 + countFormats (dropWhile (/= ')') rest)
-            '%':rest -> 1 + countFormats rest
-            _:rest -> countFormats rest
-            [] -> 0
-
-    check format more = do
-        fromMaybe (return ()) $ do
-            string <- getLiteralString format
-            let vars = countFormats string
-
-            return $ do
-                when (vars == 0 && more /= []) $
-                    err (getId format) 2182
-                        "This printf format string has no variables. Other arguments are ignored."
-
-                when (vars > 0
-                        && length more < vars
-                        && all (not . mayBecomeMultipleArgs) more) $
-                    warn (getId format) 2183 $
-                        "This format string has " ++ show vars ++ " variables, but is passed " ++ show (length more) ++ " arguments."
-
-
+    check format =
         unless ('%' `elem` concat (oversimplify format) || isLiteral format) $
-          info (getId format) 2059
+          warn (getId format) 2059
               "Don't use variables in the printf format string. Use printf \"..%s..\" \"$foo\"."
 
 
-
-
 prop_checkUuoeCmd1 = verify checkUuoeCmd "echo $(date)"
 prop_checkUuoeCmd2 = verify checkUuoeCmd "echo `date`"
 prop_checkUuoeCmd3 = verify checkUuoeCmd "echo \"$(date)\""
@@ -621,234 +556,5 @@ checkAliasesExpandEarly = CommandCheck (Exactly "alias") (f . arguments)
     checkArg _ = return ()
 
 
-prop_checkUnsetGlobs1 = verify checkUnsetGlobs "unset foo[1]"
-prop_checkUnsetGlobs2 = verifyNot checkUnsetGlobs "unset foo"
-checkUnsetGlobs = CommandCheck (Exactly "unset") (mapM_ check . arguments)
-  where
-    check arg =
-        when (isGlob arg) $
-            warn (getId arg) 2184 "Quote arguments to unset so they're not glob expanded."
-
-
-prop_checkFindWithoutPath1 = verify checkFindWithoutPath "find -type f"
-prop_checkFindWithoutPath2 = verify checkFindWithoutPath "find"
-prop_checkFindWithoutPath3 = verifyNot checkFindWithoutPath "find . -type f"
-prop_checkFindWithoutPath4 = verifyNot checkFindWithoutPath "find -H -L \"$path\" -print"
-prop_checkFindWithoutPath5 = verifyNot checkFindWithoutPath "find -O3 ."
-prop_checkFindWithoutPath6 = verifyNot checkFindWithoutPath "find -D exec ."
-checkFindWithoutPath = CommandCheck (Basename "find") f
-  where
-    f (T_SimpleCommand _ _ (cmd:args)) =
-        unless (hasPath args) $
-            info (getId cmd) 2185 "Some finds don't have a default path. Specify '.' explicitly."
-
-    -- This is a bit of a kludge. find supports flag arguments both before and after the path,
-    -- as well as multiple non-flag arguments that are not the path. We assume that all the
-    -- pre-path flags are single characters, which is generally the case except for -O3.
-    hasPath (first:rest) =
-        let flag = fromJust $ getLiteralStringExt (const $ return "___") first in
-            not ("-" `isPrefixOf` flag) || isLeadingFlag flag && hasPath rest
-    hasPath [] = False
-    isLeadingFlag flag = length flag <= 2 || "-O" `isPrefixOf` flag
-
-
-prop_checkTimeParameters1 = verify checkTimeParameters "time -f lol sleep 10"
-prop_checkTimeParameters2 = verifyNot checkTimeParameters "time sleep 10"
-prop_checkTimeParameters3 = verifyNot checkTimeParameters "time -p foo"
-prop_checkTimeParameters4 = verifyNot checkTimeParameters "command time -f lol sleep 10"
-checkTimeParameters = CommandCheck (Exactly "time") f
-  where
-    f (T_SimpleCommand _ _ (cmd:args:_)) =
-        whenShell [Bash, Sh] $
-            let s = concat $ oversimplify args in
-                when ("-" `isPrefixOf` s && s /= "-p") $
-                    info (getId cmd) 2023 "The shell may override 'time' as seen in man time(1). Use 'command time ..' for that one."
-
-    f _ = return ()
-
-prop_checkTimedCommand1 = verify checkTimedCommand "#!/bin/sh\ntime -p foo | bar"
-prop_checkTimedCommand2 = verify checkTimedCommand "#!/bin/dash\ntime ( foo; bar; )"
-prop_checkTimedCommand3 = verifyNot checkTimedCommand "#!/bin/sh\ntime sleep 1"
-checkTimedCommand = CommandCheck (Exactly "time") f where
-    f (T_SimpleCommand _ _ (c:args@(_:_))) =
-        whenShell [Sh, Dash] $ do
-            let cmd = last args -- "time" is parsed with a command as argument
-            when (isPiped cmd) $
-                warn (getId c) 2176 "'time' is undefined for pipelines. time single stage or bash -c instead."
-            when (isSimple cmd == Just False) $
-                warn (getId cmd) 2177 "'time' is undefined for compound commands, time sh -c instead."
-    f _ = return ()
-    isPiped cmd =
-        case cmd of
-            T_Pipeline _ _ (_:_:_) -> True
-            _ -> False
-    getCommand cmd =
-        case cmd of
-            T_Pipeline _ _ (T_Redirecting _ _ a : _) -> return a
-            _ -> fail ""
-    isSimple cmd = do
-        innerCommand <- getCommand cmd
-        case innerCommand of
-            T_SimpleCommand {} -> return True
-            _ -> return False
-
-prop_checkLocalScope1 = verify checkLocalScope "local foo=3"
-prop_checkLocalScope2 = verifyNot checkLocalScope "f() { local foo=3; }"
-checkLocalScope = CommandCheck (Exactly "local") $ \t ->
-    whenShell [Bash, Dash] $ do -- Ksh allows it, Sh doesn't support local
-        path <- getPathM t
-        unless (any isFunction path) $
-            err (getId t) 2168 "'local' is only valid in functions."
-
-prop_checkDeprecatedTempfile1 = verify checkDeprecatedTempfile "var=$(tempfile)"
-prop_checkDeprecatedTempfile2 = verifyNot checkDeprecatedTempfile "tempfile=$(mktemp)"
-checkDeprecatedTempfile = CommandCheck (Basename "tempfile") $
-    \t -> warn (getId t) 2186 "tempfile is deprecated. Use mktemp instead."
-
-prop_checkDeprecatedEgrep = verify checkDeprecatedEgrep "egrep '.+'"
-checkDeprecatedEgrep = CommandCheck (Basename "egrep") $
-    \t -> info (getId t) 2196 "egrep is non-standard and deprecated. Use grep -E instead."
-
-prop_checkDeprecatedFgrep = verify checkDeprecatedFgrep "fgrep '*' files"
-checkDeprecatedFgrep = CommandCheck (Basename "fgrep") $
-    \t -> info (getId t) 2197 "fgrep is non-standard and deprecated. Use grep -F instead."
-
-prop_checkWhileGetoptsCase1 = verify checkWhileGetoptsCase "while getopts 'a:b' x; do case $x in a) foo;; esac; done"
-prop_checkWhileGetoptsCase2 = verify checkWhileGetoptsCase "while getopts 'a:' x; do case $x in a) foo;; b) bar;; esac; done"
-prop_checkWhileGetoptsCase3 = verifyNot checkWhileGetoptsCase "while getopts 'a:b' x; do case $x in a) foo;; b) bar;; *) :;esac; done"
-prop_checkWhileGetoptsCase4 = verifyNot checkWhileGetoptsCase "while getopts 'a:123' x; do case $x in a) foo;; [0-9]) bar;; esac; done"
-prop_checkWhileGetoptsCase5 = verifyNot checkWhileGetoptsCase "while getopts 'a:' x; do case $x in a) foo;; \\?) bar;; *) baz;; esac; done"
-checkWhileGetoptsCase = CommandCheck (Exactly "getopts") f
-  where
-    f :: Token -> Analysis
-    f t@(T_SimpleCommand _ _ (cmd:arg1:_))  = do
-        path <- getPathM t
-        potentially $ do
-            options <- getLiteralString arg1
-            (T_WhileExpression _ _ body) <- findFirst whileLoop path
-            caseCmd <- mapMaybe findCase body !!! 0
-            return $ check (getId arg1) (map (:[]) $ filter (/= ':') options) caseCmd
-    f _ = return ()
-
-    check :: Id -> [String] -> Token -> Analysis
-    check optId opts (T_CaseExpression id _ list) = do
-            unless (Nothing `Map.member` handledMap) $ do
-                mapM_ (warnUnhandled optId id) $ catMaybes $ Map.keys notHandled
-
-                unless (any (`Map.member` handledMap) [Just "*",Just "?"]) $
-                    warn id 2220 "Invalid flags are not handled. Add a *) case."
-
-            mapM_ warnRedundant $ Map.toList notRequested
-
-        where
-            handledMap = Map.fromList (concatMap getHandledStrings list)
-            requestedMap = Map.fromList $ map (\x -> (Just x, ())) opts
-
-            notHandled = Map.difference requestedMap handledMap
-            notRequested = Map.difference handledMap requestedMap
-
-    warnUnhandled optId caseId str =
-        warn caseId 2213 $ "getopts specified -" ++ str ++ ", but it's not handled by this 'case'."
-
-    warnRedundant (key, expr) = potentially $ do
-        str <- key
-        guard $ str `notElem` ["*", ":", "?"]
-        return $ warn (getId expr) 2214 "This case is not specified by getopts."
-
-    getHandledStrings (_, globs, _) =
-        map (\x -> (literal x, x)) globs
-
-    literal :: Token -> Maybe String
-    literal t = do
-        getLiteralString t <> fromGlob t
-
-    fromGlob t =
-        case t of
-            T_Glob _ ('[':c:']':[]) -> return [c]
-            T_Glob _ "*" -> return "*"
-            T_Glob _ "?" -> return "?"
-            _ -> Nothing
-
-    whileLoop t =
-        case t of
-            T_WhileExpression {} -> return True
-            T_Script {} -> return False
-            _ -> Nothing
-
-    findCase t =
-        case t of
-            T_Annotation _ _ x -> findCase x
-            T_Pipeline _ _ [x] -> findCase x
-            T_Redirecting _ _ x@(T_CaseExpression {}) -> return x
-            _ -> Nothing
-
-prop_checkCatastrophicRm1 = verify checkCatastrophicRm "rm -r $1/$2"
-prop_checkCatastrophicRm2 = verify checkCatastrophicRm "rm -r /home/$foo"
-prop_checkCatastrophicRm3 = verifyNot checkCatastrophicRm "rm -r /home/${USER:?}/*"
-prop_checkCatastrophicRm4 = verify checkCatastrophicRm "rm -fr /home/$(whoami)/*"
-prop_checkCatastrophicRm5 = verifyNot checkCatastrophicRm "rm -r /home/${USER:-thing}/*"
-prop_checkCatastrophicRm6 = verify checkCatastrophicRm "rm --recursive /etc/*$config*"
-prop_checkCatastrophicRm8 = verify checkCatastrophicRm "rm -rf /home"
-prop_checkCatastrophicRm10= verifyNot checkCatastrophicRm "rm -r \"${DIR}\"/{.gitignore,.gitattributes,ci}"
-prop_checkCatastrophicRm11= verify checkCatastrophicRm "rm -r /{bin,sbin}/$exec"
-prop_checkCatastrophicRm12= verify checkCatastrophicRm "rm -r /{{usr,},{bin,sbin}}/$exec"
-prop_checkCatastrophicRm13= verifyNot checkCatastrophicRm "rm -r /{{a,b},{c,d}}/$exec"
-prop_checkCatastrophicRmA = verify checkCatastrophicRm "rm -rf /usr /lib/nvidia-current/xorg/xorg"
-prop_checkCatastrophicRmB = verify checkCatastrophicRm "rm -rf \"$STEAMROOT/\"*"
-checkCatastrophicRm = CommandCheck (Basename "rm") $ \t ->
-    when (isRecursive t) $
-        mapM_ (mapM_ checkWord . braceExpand) $ arguments t
-  where
-    isRecursive = any (`elem` ["r", "R", "recursive"]) . map snd . getAllFlags
-
-    checkWord token =
-        case getLiteralString token of
-            Just str ->
-                when (fixPath str `elem` importantPaths) $
-                    warn (getId token) 2114 "Warning: deletes a system directory."
-            Nothing ->
-                checkWord' token
-
-    checkWord' token = fromMaybe (return ()) $ do
-        filename <- getPotentialPath token
-        let path = fixPath filename
-        return . when (path `elem` importantPaths) $
-            warn (getId token) 2115 $ "Use \"${var:?}\" to ensure this never expands to " ++ path ++ " ."
-
-    fixPath filename =
-        let normalized = skipRepeating '/' . skipRepeating '*' $ filename in
-            if normalized == "/" then normalized else stripTrailing '/' normalized
-
-    getPotentialPath = getLiteralStringExt f
-      where
-        f (T_Glob _ str) = return str
-        f (T_DollarBraced _ word) =
-            let var = onlyLiteralString word in
-                -- This shouldn't handle non-colon cases.
-                if any (`isInfixOf` var) [":?", ":-", ":="]
-                then Nothing
-                else return ""
-        f _ = return ""
-
-    stripTrailing c = reverse . dropWhile (== c) . reverse
-    skipRepeating c (a:b:rest) | a == b && b == c = skipRepeating c (b:rest)
-    skipRepeating c (a:r) = a:skipRepeating c r
-    skipRepeating _ [] = []
-
-    paths = [
-        "", "/bin", "/etc", "/home", "/mnt", "/usr", "/usr/share", "/usr/local",
-        "/var", "/lib", "/dev", "/media", "/boot", "/lib64", "/usr/bin"
-        ]
-    importantPaths = filter (not . null) $
-        ["", "/", "/*", "/*/*"] >>= (\x -> map (++x) paths)
-
-
-prop_checkLetUsage1 = verify checkLetUsage "let a=1"
-prop_checkLetUsage2 = verifyNot checkLetUsage "(( a=1 ))"
-checkLetUsage = CommandCheck (Exactly "let") f
-  where
-    f t = whenShell [Bash,Ksh] $ do
-        style (getId t) 2219 $ "Instead of 'let expr', prefer (( expr )) ."
-
 return []
 runTests =  $( [| $(forAllProperties) (quickCheckWithResult (stdArgs { maxSuccess = 1 }) ) |])

ShellCheck/Checks/ShellSupport.hs

@@ -1,420 +0,0 @@
-{-
-    Copyright 2012-2016 Vidar Holen
-
-    This file is part of ShellCheck.
-    http://www.vidarholen.net/contents/shellcheck
-
-    ShellCheck is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    ShellCheck is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
--}
-{-# LANGUAGE TemplateHaskell #-}
-{-# LANGUAGE FlexibleContexts #-}
-module ShellCheck.Checks.ShellSupport (checker
-    , ShellCheck.Checks.ShellSupport.runTests
-) where
-
-import ShellCheck.AST
-import ShellCheck.ASTLib
-import ShellCheck.AnalyzerLib
-import ShellCheck.Interface
-import ShellCheck.Regex
-
-import Control.Monad
-import Control.Monad.RWS
-import Data.Char
-import Data.List
-import Data.Maybe
-import qualified Data.Map as Map
-import Test.QuickCheck.All (forAllProperties)
-import Test.QuickCheck.Test (quickCheckWithResult, stdArgs, maxSuccess)
-
-data ForShell = ForShell [Shell] (Token -> Analysis)
-
-getChecker params list = Checker {
-        perScript = nullCheck,
-        perToken = foldl composeAnalyzers nullCheck $ mapMaybe include list
-    }
-  where
-    shell = shellType params
-    include (ForShell list a) = do
-        guard $ shell `elem` list
-        return a
-
-checker params = getChecker params checks
-
-checks = [
-    checkForDecimals
-    ,checkBashisms
-    ,checkEchoSed
-    ,checkBraceExpansionVars
-    ,checkMultiDimensionalArrays
-    ,checkPS1Assignments
-    ]
-
-testChecker (ForShell _ t) =
-    Checker {
-        perScript = nullCheck,
-        perToken = t
-    }
-verify c s = producesComments (testChecker c) s == Just True
-verifyNot c s = producesComments (testChecker c) s == Just False
-
-prop_checkForDecimals1 = verify checkForDecimals "((3.14*c))"
-prop_checkForDecimals2 = verify checkForDecimals "foo[1.2]=bar"
-prop_checkForDecimals3 = verifyNot checkForDecimals "declare -A foo; foo[1.2]=bar"
-checkForDecimals = ForShell [Sh, Dash, Bash] f
-  where
-    f t@(TA_Expansion id _) = potentially $ do
-        str <- getLiteralString t
-        first <- str !!! 0
-        guard $ isDigit first && '.' `elem` str
-        return $ err id 2079 "(( )) doesn't support decimals. Use bc or awk."
-    f _ = return ()
-
-
-prop_checkBashisms = verify checkBashisms "while read a; do :; done < <(a)"
-prop_checkBashisms2 = verify checkBashisms "[ foo -nt bar ]"
-prop_checkBashisms3 = verify checkBashisms "echo $((i++))"
-prop_checkBashisms4 = verify checkBashisms "rm !(*.hs)"
-prop_checkBashisms5 = verify checkBashisms "source file"
-prop_checkBashisms6 = verify checkBashisms "[ \"$a\" == 42 ]"
-prop_checkBashisms7 = verify checkBashisms "echo ${var[1]}"
-prop_checkBashisms8 = verify checkBashisms "echo ${!var[@]}"
-prop_checkBashisms9 = verify checkBashisms "echo ${!var*}"
-prop_checkBashisms10= verify checkBashisms "echo ${var:4:12}"
-prop_checkBashisms11= verifyNot checkBashisms "echo ${var:-4}"
-prop_checkBashisms12= verify checkBashisms "echo ${var//foo/bar}"
-prop_checkBashisms13= verify checkBashisms "exec -c env"
-prop_checkBashisms14= verify checkBashisms "echo -n \"Foo: \""
-prop_checkBashisms15= verify checkBashisms "let n++"
-prop_checkBashisms16= verify checkBashisms "echo $RANDOM"
-prop_checkBashisms17= verify checkBashisms "echo $((RANDOM%6+1))"
-prop_checkBashisms18= verify checkBashisms "foo &> /dev/null"
-prop_checkBashisms19= verify checkBashisms "foo > file*.txt"
-prop_checkBashisms20= verify checkBashisms "read -ra foo"
-prop_checkBashisms21= verify checkBashisms "[ -a foo ]"
-prop_checkBashisms22= verifyNot checkBashisms "[ foo -a bar ]"
-prop_checkBashisms23= verify checkBashisms "trap mything ERR INT"
-prop_checkBashisms24= verifyNot checkBashisms "trap mything INT TERM"
-prop_checkBashisms25= verify checkBashisms "cat < /dev/tcp/host/123"
-prop_checkBashisms26= verify checkBashisms "trap mything ERR SIGTERM"
-prop_checkBashisms27= verify checkBashisms "echo *[^0-9]*"
-prop_checkBashisms28= verify checkBashisms "exec {n}>&2"
-prop_checkBashisms29= verify checkBashisms "echo ${!var}"
-prop_checkBashisms30= verify checkBashisms "printf -v '%s' \"$1\""
-prop_checkBashisms31= verify checkBashisms "printf '%q' \"$1\""
-prop_checkBashisms32= verifyNot checkBashisms "#!/bin/dash\n[ foo -nt bar ]"
-prop_checkBashisms33= verify checkBashisms "#!/bin/sh\necho -n foo"
-prop_checkBashisms34= verifyNot checkBashisms "#!/bin/dash\necho -n foo"
-prop_checkBashisms35= verifyNot checkBashisms "#!/bin/dash\nlocal foo"
-prop_checkBashisms36= verifyNot checkBashisms "#!/bin/dash\nread -p foo -r bar"
-prop_checkBashisms37= verifyNot checkBashisms "HOSTNAME=foo; echo $HOSTNAME"
-prop_checkBashisms38= verify checkBashisms "RANDOM=9; echo $RANDOM"
-prop_checkBashisms39= verify checkBashisms "foo-bar() { true; }"
-prop_checkBashisms40= verify checkBashisms "echo $(<file)"
-prop_checkBashisms41= verify checkBashisms "echo `<file`"
-prop_checkBashisms42= verify checkBashisms "trap foo int"
-prop_checkBashisms43= verify checkBashisms "trap foo sigint"
-prop_checkBashisms44= verifyNot checkBashisms "#!/bin/dash\ntrap foo int"
-prop_checkBashisms45= verifyNot checkBashisms "#!/bin/dash\ntrap foo INT"
-prop_checkBashisms46= verify checkBashisms "#!/bin/dash\ntrap foo SIGINT"
-prop_checkBashisms47= verify checkBashisms "#!/bin/dash\necho foo 42>/dev/null"
-prop_checkBashisms48= verifyNot checkBashisms "#!/bin/dash\necho $LINENO"
-prop_checkBashisms49= verify checkBashisms "#!/bin/dash\necho $MACHTYPE"
-prop_checkBashisms50= verify checkBashisms "#!/bin/sh\ncmd >& file"
-prop_checkBashisms51= verifyNot checkBashisms "#!/bin/sh\ncmd 2>&1"
-prop_checkBashisms52= verifyNot checkBashisms "#!/bin/sh\ncmd >&2"
-prop_checkBashisms53= verifyNot checkBashisms "#!/bin/sh\nprintf -- -f\n"
-prop_checkBashisms54= verify checkBashisms "#!/bin/sh\nfoo+=bar"
-checkBashisms = ForShell [Sh, Dash] $ \t -> do
-    params <- ask
-    kludge params t
- where
-  -- This code was copy-pasted from Analytics where params was a variable
-  kludge params = bashism
-   where
-    isDash = shellType params == Dash
-    warnMsg id s =
-        if isDash
-        then warn id 2169 $ "In dash, " ++ s ++ " not supported."
-        else warn id 2039 $ "In POSIX sh, " ++ s ++ " undefined."
-
-    bashism (T_ProcSub id _ _) = warnMsg id "process substitution is"
-    bashism (T_Extglob id _ _) = warnMsg id "extglob is"
-    bashism (T_DollarSingleQuoted id _) = warnMsg id "$'..' is"
-    bashism (T_DollarDoubleQuoted id _) = warnMsg id "$\"..\" is"
-    bashism (T_ForArithmetic id _ _ _ _) = warnMsg id "arithmetic for loops are"
-    bashism (T_Arithmetic id _) = warnMsg id "standalone ((..)) is"
-    bashism (T_DollarBracket id _) = warnMsg id "$[..] in place of $((..)) is"
-    bashism (T_SelectIn id _ _ _) = warnMsg id "select loops are"
-    bashism (T_BraceExpansion id _) = warnMsg id "brace expansion is"
-    bashism (T_Condition id DoubleBracket _) = warnMsg id "[[ ]] is"
-    bashism (T_HereString id _) = warnMsg id "here-strings are"
-    bashism (TC_Binary id SingleBracket op _ _)
-        | op `elem` [ "<", ">", "\\<", "\\>", "<=", ">=", "\\<=", "\\>="] =
-            unless isDash $ warnMsg id $ "lexicographical " ++ op ++ " is"
-    bashism (TC_Binary id SingleBracket op _ _)
-        | op `elem` [ "-nt", "-ef" ] =
-            unless isDash $ warnMsg id $ op ++ " is"
-    bashism (TC_Binary id SingleBracket "==" _ _) =
-            warnMsg id "== in place of = is"
-    bashism (TC_Binary id SingleBracket "=~" _ _) =
-            warnMsg id "=~ regex matching is"
-    bashism (TC_Unary id _ "-a" _) =
-            warnMsg id "unary -a in place of -e is"
-    bashism (TA_Unary id op _)
-        | op `elem` [ "|++", "|--", "++|", "--|"] =
-            warnMsg id $ filter (/= '|') op ++ " is"
-    bashism (TA_Binary id "**" _ _) = warnMsg id "exponentials are"
-    bashism (T_FdRedirect id "&" (T_IoFile _ (T_Greater _) _)) = warnMsg id "&> is"
-    bashism (T_FdRedirect id "" (T_IoFile _ (T_GREATAND _) _)) = warnMsg id ">& is"
-    bashism (T_FdRedirect id ('{':_) _) = warnMsg id "named file descriptors are"
-    bashism (T_FdRedirect id num _)
-        | all isDigit num && length num > 1 = warnMsg id "FDs outside 0-9 are"
-    bashism (T_Assignment id Append _ _ _) =
-        warnMsg id "+= is"
-    bashism (T_IoFile id _ word) | isNetworked =
-            warnMsg id "/dev/{tcp,udp} is"
-        where
-            file = onlyLiteralString word
-            isNetworked = any (`isPrefixOf` file) ["/dev/tcp", "/dev/udp"]
-    bashism (T_Glob id str) | "[^" `isInfixOf` str =
-            warnMsg id "^ in place of ! in glob bracket expressions is"
-
-    bashism t@(TA_Expansion id _) | isBashism =
-        warnMsg id $ fromJust str ++ " is"
-      where
-        str = getLiteralString t
-        isBashism = isJust str && isBashVariable (fromJust str)
-    bashism t@(T_DollarBraced id token) = do
-        mapM_ check expansion
-        when (isBashVariable var) $
-                    warnMsg id $ var ++ " is"
-      where
-        str = bracedString t
-        var = getBracedReference str
-        check (regex, feature) =
-            when (isJust $ matchRegex regex str) $ warnMsg id feature
-
-    bashism t@(T_Pipe id "|&") =
-        warnMsg id "|& in place of 2>&1 | is"
-    bashism (T_Array id _) =
-        warnMsg id "arrays are"
-    bashism (T_IoFile id _ t) | isGlob t =
-        warnMsg id "redirecting to/from globs is"
-    bashism (T_CoProc id _ _) =
-        warnMsg id "coproc is"
-
-    bashism (T_Function id _ _ str _) | not (isVariableName str) =
-        warnMsg id "naming functions outside [a-zA-Z_][a-zA-Z0-9_]* is"
-
-    bashism (T_DollarExpansion id [x]) | isOnlyRedirection x =
-        warnMsg id "$(<file) to read files is"
-    bashism (T_Backticked id [x]) | isOnlyRedirection x =
-        warnMsg id "`<file` to read files is"
-
-    bashism t@(T_SimpleCommand _ _ (cmd:arg:_))
-        | t `isCommand` "echo" && "-" `isPrefixOf` argString =
-            unless ("--" `isPrefixOf` argString) $ -- echo "-----"
-                if isDash
-                then
-                    when (argString /= "-n") $
-                        warnMsg (getId arg) "echo flags besides -n"
-                else
-                    warnMsg (getId arg) "echo flags are"
-      where argString = concat $ oversimplify arg
-    bashism t@(T_SimpleCommand _ _ (cmd:arg:_))
-        | t `isCommand` "exec" && "-" `isPrefixOf` concat (oversimplify arg) =
-            warnMsg (getId arg) "exec flags are"
-    bashism t@(T_SimpleCommand id _ _)
-        | t `isCommand` "let" = warnMsg id "'let' is"
-
-    bashism t@(T_SimpleCommand id _ (cmd:rest)) =
-        let name = fromMaybe "" $ getCommandName t
-            flags = getLeadingFlags t
-        in do
-            when (name `elem` unsupportedCommands) $
-                warnMsg id $ "'" ++ name ++ "' is"
-            potentially $ do
-                allowed <- Map.lookup name allowedFlags
-                (word, flag) <- listToMaybe $
-                    filter (\x -> (not . null . snd $ x) && snd x `notElem` allowed) flags
-                return . warnMsg (getId word) $ name ++ " -" ++ flag ++ " is"
-
-            when (name == "source") $ warnMsg id "'source' in place of '.' is"
-            when (name == "trap") $
-                let
-                    check token = potentially $ do
-                        str <- getLiteralString token
-                        let upper = map toUpper str
-                        return $ do
-                            when (upper `elem` ["ERR", "DEBUG", "RETURN"]) $
-                                warnMsg (getId token) $ "trapping " ++ str ++ " is"
-                            when ("SIG" `isPrefixOf` upper) $
-                                warnMsg (getId token)
-                                    "prefixing signal names with 'SIG' is"
-                            when (not isDash && upper /= str) $
-                                warnMsg (getId token)
-                                    "using lower/mixed case for signal names is"
-                in
-                    mapM_ check (drop 1 rest)
-
-            when (name == "printf") $ potentially $ do
-                format <- rest !!! 0  -- flags are covered by allowedFlags
-                let literal = onlyLiteralString format
-                guard $ "%q" `isInfixOf` literal
-                return $ warnMsg (getId format) "printf %q is"
-      where
-        unsupportedCommands = [
-            "let", "caller", "builtin", "complete", "compgen", "declare", "dirs", "disown",
-            "enable", "mapfile", "readarray", "pushd", "popd", "shopt", "suspend",
-            "typeset"
-            ] ++ if not isDash then ["local", "type"] else []
-        allowedFlags = Map.fromList [
-            ("read", if isDash then ["r", "p"] else ["r"]),
-            ("ulimit", ["f"]),
-            ("printf", []),
-            ("exec", [])
-            ]
-
-    bashism _ = return ()
-
-    varChars="_0-9a-zA-Z"
-    expansion = let re = mkRegex in [
-        (re $ "^![" ++ varChars ++ "]", "indirect expansion is"),
-        (re $ "^[" ++ varChars ++ "]+\\[.*\\]$", "array references are"),
-        (re $ "^![" ++ varChars ++ "]+\\[[*@]]$", "array key expansion is"),
-        (re $ "^![" ++ varChars ++ "]+[*@]$", "name matching prefixes are"),
-        (re $ "^[" ++ varChars ++ "]+:[^-=?+]", "string indexing is"),
-        (re $ "^[" ++ varChars ++ "]+(\\[.*\\])?/", "string replacement is")
-        ]
-    bashVars = [
-        "LINENO", "OSTYPE", "MACHTYPE", "HOSTTYPE", "HOSTNAME",
-        "DIRSTACK", "EUID", "UID", "SHLVL", "PIPESTATUS", "SHELLOPTS"
-        ]
-    bashDynamicVars = [ "RANDOM", "SECONDS" ]
-    dashVars = [ "LINENO" ]
-    isBashVariable var =
-        (var `elem` bashDynamicVars
-            || var `elem` bashVars && not (isAssigned var))
-        && not (isDash && var `elem` dashVars)
-    isAssigned var = any f (variableFlow params)
-      where
-        f x = case x of
-                Assignment (_, _, name, _) -> name == var
-                _ -> False
-
-prop_checkEchoSed1 = verify checkEchoSed "FOO=$(echo \"$cow\" | sed 's/foo/bar/g')"
-prop_checkEchoSed2 = verify checkEchoSed "rm $(echo $cow | sed -e 's,foo,bar,')"
-checkEchoSed = ForShell [Bash, Ksh] f
-  where
-    f (T_Pipeline id _ [a, b]) =
-        when (acmd == ["echo", "${VAR}"]) $
-            case bcmd of
-                ["sed", v] -> checkIn v
-                ["sed", "-e", v] -> checkIn v
-                _ -> return ()
-      where
-        -- This should have used backreferences, but TDFA doesn't support them
-        sedRe = mkRegex "^s(.)([^\n]*)g?$"
-        isSimpleSed s = fromMaybe False $ do
-            [first,rest] <- matchRegex sedRe s
-            let delimiters = filter (== head first) rest
-            guard $ length delimiters == 2
-            return True
-
-        acmd = oversimplify a
-        bcmd = oversimplify b
-        checkIn s =
-            when (isSimpleSed s) $
-                style id 2001 "See if you can use ${variable//search/replace} instead."
-    f _ = return ()
-
-
-prop_checkBraceExpansionVars1 = verify checkBraceExpansionVars "echo {1..$n}"
-prop_checkBraceExpansionVars2 = verifyNot checkBraceExpansionVars "echo {1,3,$n}"
-prop_checkBraceExpansionVars3 = verify checkBraceExpansionVars "eval echo DSC{0001..$n}.jpg"
-prop_checkBraceExpansionVars4 = verify checkBraceExpansionVars "echo {$i..100}"
-checkBraceExpansionVars = ForShell [Bash] f
-  where
-    f t@(T_BraceExpansion id list) = mapM_ check list
-      where
-        check element =
-            when (any (`isInfixOf` toString element) ["$..", "..$"]) $ do
-                c <- isEvaled element
-                if c
-                    then style id 2175 "Quote this invalid brace expansion since it should be passed literally to eval."
-                    else warn id 2051 "Bash doesn't support variables in brace range expansions."
-    f _ = return ()
-
-    literalExt t =
-        case t of
-            T_DollarBraced {} -> return "$"
-            T_DollarExpansion {} -> return "$"
-            T_DollarArithmetic {} -> return "$"
-            otherwise -> return "-"
-    toString t = fromJust $ getLiteralStringExt literalExt t
-    isEvaled t = do
-        cmd <- getClosestCommandM t
-        return $ isJust cmd && fromJust cmd `isUnqualifiedCommand` "eval"
-
-
-prop_checkMultiDimensionalArrays1 = verify checkMultiDimensionalArrays "foo[a][b]=3"
-prop_checkMultiDimensionalArrays2 = verifyNot checkMultiDimensionalArrays "foo[a]=3"
-prop_checkMultiDimensionalArrays3 = verify checkMultiDimensionalArrays "foo=( [a][b]=c )"
-prop_checkMultiDimensionalArrays4 = verifyNot checkMultiDimensionalArrays "foo=( [a]=c )"
-prop_checkMultiDimensionalArrays5 = verify checkMultiDimensionalArrays "echo ${foo[bar][baz]}"
-prop_checkMultiDimensionalArrays6 = verifyNot checkMultiDimensionalArrays "echo ${foo[bar]}"
-checkMultiDimensionalArrays = ForShell [Bash] f
-  where
-    f token =
-        case token of
-            T_Assignment _ _ name (first:second:_) _ -> about second
-            T_IndexedElement _ (first:second:_) _ -> about second
-            T_DollarBraced {} ->
-                when (isMultiDim token) $ about token
-            _ -> return ()
-    about t = warn (getId t) 2180 "Bash does not support multidimensional arrays. Use 1D or associative arrays."
-
-    re = mkRegex "^\\[.*\\]\\[.*\\]"  -- Fixme, this matches ${foo:- [][]} and such as well
-    isMultiDim t = getBracedModifier (bracedString t) `matches` re
-
-prop_checkPS11 = verify checkPS1Assignments "PS1='\\033[1;35m\\$ '"
-prop_checkPS11a= verify checkPS1Assignments "export PS1='\\033[1;35m\\$ '"
-prop_checkPSf2 = verify checkPS1Assignments "PS1='\\h \\e[0m\\$ '"
-prop_checkPS13 = verify checkPS1Assignments "PS1=$'\\x1b[c '"
-prop_checkPS14 = verify checkPS1Assignments "PS1=$'\\e[3m; '"
-prop_checkPS14a= verify checkPS1Assignments "export PS1=$'\\e[3m; '"
-prop_checkPS15 = verifyNot checkPS1Assignments "PS1='\\[\\033[1;35m\\]\\$ '"
-prop_checkPS16 = verifyNot checkPS1Assignments "PS1='\\[\\e1m\\e[1m\\]\\$ '"
-prop_checkPS17 = verifyNot checkPS1Assignments "PS1='e033x1B'"
-prop_checkPS18 = verifyNot checkPS1Assignments "PS1='\\[\\e\\]'"
-checkPS1Assignments = ForShell [Bash] f
-  where
-    f token = case token of
-        (T_Assignment _ _ "PS1" _ word) -> warnFor word
-        _ -> return ()
-
-    warnFor word =
-        let contents = concat $ oversimplify word in
-            when (containsUnescaped contents) $
-                info (getId word) 2025 "Make sure all escape sequences are enclosed in \\[..\\] to prevent line wrapping issues"
-    containsUnescaped s =
-        let unenclosed = subRegex enclosedRegex s "" in
-           isJust $ matchRegex escapeRegex unenclosed
-    enclosedRegex = mkRegex "\\\\\\[.*\\\\\\]" -- FIXME: shouldn't be eager
-    escapeRegex = mkRegex "\\\\x1[Bb]|\\\\e|\x1B|\\\\033"
-
-
-return []
-runTests =  $( [| $(forAllProperties) (quickCheckWithResult (stdArgs { maxSuccess = 1 }) ) |])

ShellCheck/Data.hs

@@ -33,9 +33,6 @@ internalVariables = [
     -- Other
     "USER", "TZ", "TERM", "LOGNAME", "LD_LIBRARY_PATH", "LANGUAGE", "DISPLAY",
     "HOSTNAME", "KRB5CCNAME", "XAUTHORITY"
-
-    -- Ksh
-    , ".sh.version"
   ]
 
 variablesWithoutSpaces = [
@@ -77,14 +74,6 @@ commonCommands = [
     "zcat"
   ]
 
-nonReadingCommands = [
-    "alias", "basename", "bg", "cal", "cd", "chgrp", "chmod", "chown",
-    "cp", "du", "echo", "export", "fg", "fuser", "getconf", "getopt",
-    "getopts", "ipcrm", "ipcs", "jobs", "kill", "ln", "ls", "locale", "mv",
-    "nice", "printf", "ps", "pwd", "renice", "rm", "rmdir", "set", "sleep",
-    "touch", "trap", "ulimit", "unalias", "uname"
-    ]
-
 sampleWords = [
     "alpha", "bravo", "charlie", "delta", "echo", "foxtrot",
     "golf", "hotel", "india", "juliett", "kilo", "lima", "mike",
@@ -93,24 +82,12 @@ sampleWords = [
     "zulu"
   ]
 
-binaryTestOps = [
-    "-nt", "-ot", "-ef", "==", "!=", "<=", ">=", "-eq", "-ne", "-lt", "-le",
-    "-gt", "-ge", "=~", ">", "<", "=", "\\<", "\\>", "\\<=", "\\>="
-  ]
-
-unaryTestOps = [
-    "!", "-a", "-b", "-c", "-d", "-e", "-f", "-g", "-h", "-L", "-k", "-p",
-    "-r", "-s", "-S", "-t", "-u", "-w", "-x", "-O", "-G", "-N", "-z", "-n",
-    "-o", "-v", "-R"
-  ]
-
 shellForExecutable :: String -> Maybe Shell
 shellForExecutable name =
     case name of
         "sh"    -> return Sh
         "bash"  -> return Bash
         "dash"  -> return Dash
-        "ash"   -> return Dash -- There's also a warning for this.
         "ksh"   -> return Ksh
         "ksh88" -> return Ksh
         "ksh93" -> return Ksh

ShellCheck/Formatter/CheckStyle.hs

@@ -34,27 +34,14 @@ format = return Formatter {
         putStrLn "<checkstyle version='4.3'>",
 
     onFailure = outputError,
-    onResult = outputResults,
+    onResult = outputResult,
 
     footer = putStrLn "</checkstyle>"
 }
 
-outputResults cr sys =
-    if null comments
-    then outputFile (crFilename cr) "" []
-    else mapM_ outputGroup fileGroups
-  where
-    comments = crComments cr
-    fileGroups = groupWith sourceFile comments
-    outputGroup group = do
-        let filename = sourceFile (head group)
-        result <- (siReadFile sys) filename
-        let contents = either (const "") id result
-        outputFile filename contents group
-
-outputFile filename contents warnings = do
-    let comments = makeNonVirtual warnings contents
-    putStrLn . formatFile filename $ comments
+outputResult result contents = do
+    let comments = makeNonVirtual (crComments result) contents
+    putStrLn . formatFile (crFilename result) $ comments
 
 formatFile name comments = concat [
     "<file ", attr "name" name, ">\n",

ShellCheck/Formatter/Format.hs

@@ -25,21 +25,18 @@ import ShellCheck.Interface
 -- A formatter that carries along an arbitrary piece of data
 data Formatter = Formatter {
     header ::  IO (),
-    onResult :: CheckResult -> SystemInterface IO -> IO (),
+    onResult :: CheckResult -> String -> IO (),
     onFailure :: FilePath -> ErrorMessage -> IO (),
     footer :: IO ()
 }
 
-sourceFile (PositionedComment pos _ _) = posFile pos
-lineNo (PositionedComment pos _ _) = posLine pos
-endLineNo (PositionedComment _ end _) = posLine end
-colNo  (PositionedComment pos _ _) = posColumn pos
-endColNo  (PositionedComment _ end _) = posColumn end
-codeNo (PositionedComment _ _ (Comment _ code _)) = code
-messageText (PositionedComment _ _ (Comment _ _ t)) = t
+lineNo (PositionedComment pos _) = posLine pos
+colNo  (PositionedComment pos _) = posColumn pos
+codeNo (PositionedComment _ (Comment _ code _)) = code
+messageText (PositionedComment _ (Comment _ _ t)) = t
 
 severityText :: PositionedComment -> String
-severityText (PositionedComment _ _ (Comment c _ _)) =
+severityText (PositionedComment _ (Comment c _ _)) =
     case c of
         ErrorC   -> "error"
         WarningC -> "warning"
@@ -51,15 +48,12 @@ makeNonVirtual comments contents =
     map fix comments
   where
     ls = lines contents
-    fix c@(PositionedComment start end comment) = PositionedComment start {
-        posColumn = realignColumn lineNo colNo c
-    } end {
-        posColumn = realignColumn endLineNo endColNo c
+    fix c@(PositionedComment pos comment) = PositionedComment pos {
+        posColumn =
+            if lineNo c > 0 && lineNo c <= fromIntegral (length ls)
+            then real (ls !! fromIntegral (lineNo c - 1)) 0 0 (colNo c)
+            else colNo c
     } comment
-    realignColumn lineNo colNo c =
-      if lineNo c > 0 && lineNo c <= fromIntegral (length ls)
-      then real (ls !! fromIntegral (lineNo c - 1)) 0 0 (colNo c)
-      else colNo c
     real _ r v target | target <= v = r
     real [] r v _ = r -- should never happen
     real ('\t':rest) r v target =

ShellCheck/Formatter/GCC.hs

@@ -31,25 +31,14 @@ format = return Formatter {
     header = return (),
     footer = return (),
     onFailure = outputError,
-    onResult = outputAll
+    onResult = outputResult
 }
 
 outputError file error = hPutStrLn stderr $ file ++ ": " ++ error
 
-outputAll cr sys = mapM_ f groups
-  where
-    comments = crComments cr
-    groups = groupWith sourceFile comments
-    f :: [PositionedComment] -> IO ()
-    f group = do
-        let filename = sourceFile (head group)
-        result <- (siReadFile sys) filename
-        let contents = either (const "") id result
-        outputResult filename contents group
-
-outputResult filename contents warnings = do
-    let comments = makeNonVirtual warnings contents
-    mapM_ (putStrLn . formatComment filename) comments
+outputResult result contents = do
+    let comments = makeNonVirtual (crComments result) contents
+    mapM_ (putStrLn . formatComment (crFilename result)) comments
 
 formatComment filename c = concat [
     filename, ":",

ShellCheck/Formatter/JSON.hs

@@ -37,12 +37,10 @@ format = do
     }
 
 instance JSON (PositionedComment) where
-  showJSON comment@(PositionedComment start end (Comment level code string)) = makeObj [
-      ("file", showJSON $ posFile start),
-      ("line", showJSON $ posLine start),
-      ("endLine", showJSON $ posLine end),
-      ("column", showJSON $ posColumn start),
-      ("endColumn", showJSON $ posColumn end),
+  showJSON comment@(PositionedComment pos (Comment level code string)) = makeObj [
+      ("file", showJSON $ posFile pos),
+      ("line", showJSON $ posLine pos),
+      ("column", showJSON $ posColumn pos),
       ("level", showJSON $ severityText comment),
       ("code", showJSON code),
       ("message", showJSON string)

ShellCheck/Formatter/TTY.hs

@@ -43,22 +43,15 @@ colorForLevel level =
         "style"   -> 32 -- green
         "message" -> 1 -- bold
         "source"  -> 0 -- none
-        _ -> 0         -- none
+        otherwise -> 0 -- none
 
 outputError options file error = do
     color <- getColorFunc $ foColorOption options
     hPutStrLn stderr $ color "error" $ file ++ ": " ++ error
 
-outputResult options result sys = do
+outputResult options result contents = do
     color <- getColorFunc $ foColorOption options
     let comments = crComments result
-    let fileGroups = groupWith sourceFile comments
-    mapM_ (outputForFile color sys) fileGroups
-
-outputForFile color sys comments = do
-    let fileName = sourceFile (head comments)
-    result <- (siReadFile sys) fileName
-    let contents = either (const "") id result
     let fileLines = lines contents
     let lineCount = fromIntegral $ length fileLines
     let groups = groupWith lineNo comments
@@ -69,7 +62,7 @@ outputForFile color sys comments = do
                         else fileLines !! fromIntegral (lineNum - 1)
         putStrLn ""
         putStrLn $ color "message" $
-           "In " ++ fileName ++" line " ++ show lineNum ++ ":"
+           "In " ++ crFilename result ++" line " ++ show lineNum ++ ":"
         putStrLn (color "source" line)
         mapM_ (\c -> putStrLn (color (severityText c) $ cuteIndent c)) x
         putStrLn ""

ShellCheck/Interface.hs

@@ -24,7 +24,7 @@ import Control.Monad.Identity
 import qualified Data.Map as Map
 
 
-newtype SystemInterface m = SystemInterface {
+data SystemInterface m = SystemInterface {
     -- Read a file by filename, or return an error
     siReadFile :: String -> m (Either ErrorMessage String)
 }
@@ -33,7 +33,6 @@ newtype SystemInterface m = SystemInterface {
 data CheckSpec = CheckSpec {
     csFilename :: String,
     csScript :: String,
-    csCheckSourced :: Bool,
     csExcludedWarnings :: [Integer],
     csShellTypeOverride :: Maybe Shell
 } deriving (Show, Eq)
@@ -43,11 +42,9 @@ data CheckResult = CheckResult {
     crComments :: [PositionedComment]
 } deriving (Show, Eq)
 
-emptyCheckSpec :: CheckSpec
 emptyCheckSpec = CheckSpec {
     csFilename = "",
     csScript = "",
-    csCheckSourced = False,
     csExcludedWarnings = [],
     csShellTypeOverride = Nothing
 }
@@ -55,8 +52,7 @@ emptyCheckSpec = CheckSpec {
 -- Parser input and output
 data ParseSpec = ParseSpec {
     psFilename :: String,
-    psScript :: String,
-    psCheckSourced :: Bool
+    psScript :: String
 } deriving (Show, Eq)
 
 data ParseResult = ParseResult {
@@ -69,17 +65,16 @@ data ParseResult = ParseResult {
 data AnalysisSpec = AnalysisSpec {
     asScript :: Token,
     asShellType :: Maybe Shell,
-    asExecutionMode :: ExecutionMode,
-    asCheckSourced :: Bool
+    asExecutionMode :: ExecutionMode
 }
 
-newtype AnalysisResult = AnalysisResult {
+data AnalysisResult = AnalysisResult {
     arComments :: [TokenComment]
 }
 
 
 -- Formatter options
-newtype FormatterOptions = FormatterOptions {
+data FormatterOptions = FormatterOptions {
     foColorOption :: ColorOption
 }
 
@@ -99,7 +94,7 @@ data Position = Position {
 } deriving (Show, Eq)
 
 data Comment = Comment Severity Code String deriving (Show, Eq)
-data PositionedComment = PositionedComment Position Position Comment deriving (Show, Eq)
+data PositionedComment = PositionedComment Position Comment deriving (Show, Eq)
 data TokenComment = TokenComment Id Comment deriving (Show, Eq)
 
 data ColorOption =

nextnumber

@@ -1,10 +0,0 @@
-#!/bin/bash
-# TODO: Find a less trashy way to get the next available error code
-
-shopt -s globstar
-
-for i in 1 2
-do
-  last=$(grep -hv "^prop" ./**/*.hs | grep -Ewo "$i[0-9]{3}" | sort -n | tail -n 1)
-  echo "Next ${i}xxx: $((last+1))"
-done

quicktest

@@ -9,7 +9,6 @@
   ,ShellCheck.Parser.runTests
   ,ShellCheck.Checker.runTests
   ,ShellCheck.Checks.Commands.runTests
-  ,ShellCheck.Checks.ShellSupport.runTests
   ,ShellCheck.AnalyzerLib.runTests
     ]' | tr -d '\n' | cabal repl 2>&1 | tee /dev/stderr)
 if [[ $var == *$'\nTrue'* ]]

shellcheck.1.md

@@ -32,12 +32,6 @@ not warn at all, as `ksh` supports decimals in arithmetic contexts.
 
 # OPTIONS
 
-**-a**,\ **--check-sourced**
-
-:   Emit warnings in sourced files. Normally, `shellcheck` will only warn
-    about issues in the specified files. With this option, any issues in
-    sourced files files will also be reported.
-
 **-C**[*WHEN*],\ **--color**[=*WHEN*]
 
 :   For TTY output, enable colors *always*, *never* or *auto*. The default
@@ -73,7 +67,6 @@ not warn at all, as `ksh` supports decimals in arithmetic contexts.
     line (plus `/dev/null`). This option allows following any file the script
     may `source`.
 
-
 # FORMATS
 
 **tty**
@@ -164,11 +157,6 @@ Valid keys are:
     used to tell shellcheck where to look for a file whose name is determined
     at runtime, or to skip a source by telling it to use `/dev/null`.
 
-**shell**
-:   Overrides the shell detected from the shebang.  This is useful for
-    files meant to be included (and thus lacking a shebang), or possibly
-    as a more targeted alternative to 'disable=2039'.
-
 # ENVIRONMENT VARIABLES
 The environment variable `SHELLCHECK_OPTS` can be set with default flags:
 
@@ -187,15 +175,6 @@ ShellCheck uses the follow exit codes:
 + 3: ShellCheck was invoked with bad syntax (e.g. unknown flag).
 + 4: ShellCheck was invoked with bad options (e.g. unknown formatter).
 
-# LOCALE
-This version of ShellCheck is only available in English. All files are
-leniently decoded as UTF-8, with a fallback of ISO-8859-1 for invalid
-sequences. `LC_CTYPE` is respected for output, and defaults to UTF-8 for
-locales where encoding is unspecified (such as the `C` locale).
-
-Windows users seeing `commitBuffer: invalid argument (invalid character)`
-should set their terminal to use UTF-8 with `chcp 65001`.
-
 # AUTHOR
 ShellCheck is written and maintained by Vidar Holen.
 

shellcheck.hs

@@ -31,12 +31,9 @@ import qualified ShellCheck.Formatter.TTY
 import Control.Exception
 import Control.Monad
 import Control.Monad.Except
-import Data.Bits
 import Data.Char
-import Data.Either
 import Data.Functor
-import Data.IORef
-import Data.List
+import Data.Either
 import qualified Data.Map as Map
 import Data.Maybe
 import Data.Monoid
@@ -76,23 +73,19 @@ defaultOptions = Options {
 
 usageHeader = "Usage: shellcheck [OPTIONS...] FILES..."
 options = [
-    Option "a" ["check-sourced"]
-        (NoArg $ Flag "sourced" "false") "Include warnings from sourced files",
+    Option "e" ["exclude"]
+        (ReqArg (Flag "exclude") "CODE1,CODE2..") "exclude types of warnings",
+    Option "f" ["format"]
+        (ReqArg (Flag "format") "FORMAT") "output format",
     Option "C" ["color"]
         (OptArg (maybe (Flag "color" "always") (Flag "color")) "WHEN")
         "Use color (auto, always, never)",
-    Option "e" ["exclude"]
-        (ReqArg (Flag "exclude") "CODE1,CODE2..") "Exclude types of warnings",
-    Option "f" ["format"]
-        (ReqArg (Flag "format") "FORMAT") $
-        "Output format (" ++ formatList ++ ")",
     Option "s" ["shell"]
-        (ReqArg (Flag "shell") "SHELLNAME")
-        "Specify dialect (sh, bash, dash, ksh)",
-    Option "V" ["version"]
-        (NoArg $ Flag "version" "true") "Print version information",
+        (ReqArg (Flag "shell") "SHELLNAME") "Specify dialect (sh,bash,dash,ksh)",
     Option "x" ["external-sources"]
-        (NoArg $ Flag "externals" "true") "Allow 'source' outside of FILES"
+        (NoArg $ Flag "externals" "true") "Allow 'source' outside of FILES.",
+    Option "V" ["version"]
+        (NoArg $ Flag "version" "true") "Print version information"
     ]
 
 printErr = lift . hPutStrLn stderr
@@ -113,10 +106,6 @@ formats options = Map.fromList [
     ("tty",  ShellCheck.Formatter.TTY.format options)
     ]
 
-formatList = intercalate ", " names
-  where
-    names = Map.keys $ formats (formatterOptions defaultOptions)
-
 getOption [] _ = Nothing
 getOption (Flag var val:_) name | name == var = return val
 getOption (_:rest) flag = getOption rest flag
@@ -139,7 +128,7 @@ getExclusions options =
     in
         map (Prelude.read . clean) elements :: [Int]
 
-toStatus = fmap (either id id) . runExceptT
+toStatus = liftM (either id id) . runExceptT
 
 getEnvArgs = do
     opts <- getEnv "SHELLCHECK_OPTS" `catch` cantWaitForLookupEnv
@@ -196,27 +185,23 @@ runFormatter sys format options files = do
         newStatus <- process file `catch` handler file
         return $ status `mappend` newStatus
     handler :: FilePath -> IOException -> IO Status
-    handler file e = reportFailure file (show e)
-    reportFailure file str = do
-        onFailure format file str
+    handler file e = do
+        onFailure format file (show e)
         return RuntimeException
 
     process :: FilePath -> IO Status
     process filename = do
-        input <- (siReadFile sys) filename
-        either (reportFailure filename) check input
-      where
-        check contents = do
-            let checkspec = (checkSpec options) {
-                csFilename = filename,
-                csScript = contents
-            }
-            result <- checkScript sys checkspec
-            onResult format result sys
-            return $
-                if null (crComments result)
-                then NoProblems
-                else SomeProblems
+        contents <- inputFile filename
+        let checkspec = (checkSpec options) {
+            csFilename = filename,
+            csScript = contents
+        }
+        result <- checkScript sys checkspec
+        onResult format result contents
+        return $
+            if null (crComments result)
+            then NoProblems
+            else SomeProblems
 
 parseColorOption colorOption =
     case colorOption of
@@ -261,13 +246,6 @@ parseOption flag options =
                 }
             }
 
-        Flag "sourced" _ ->
-            return options {
-                checkSpec = (checkSpec options) {
-                    csCheckSourced = True
-                }
-            }
-
         _ -> return options
   where
     die s = do
@@ -282,28 +260,14 @@ parseOption flag options =
 
 ioInterface options files = do
     inputs <- mapM normalize files
-    cache <- newIORef emptyCache
     return SystemInterface {
-        siReadFile = get cache inputs
+        siReadFile = get inputs
     }
   where
-    emptyCache :: Map.Map FilePath String
-    emptyCache = Map.empty
-    get cache inputs file = do
-        map <- readIORef cache
-        case Map.lookup file map of
-            Just x -> return $ Right x
-            Nothing -> fetch cache inputs file
-
-    fetch cache inputs file = do
+    get inputs file = do
         ok <- allowable inputs file
         if ok
-          then (do
-            (contents, shouldCache) <- inputFile file
-            when shouldCache $
-                modifyIORef cache $ Map.insert file contents
-            return $ Right contents
-            ) `catch` handler
+          then (Right <$> inputFile file) `catch` handler
           else return $ Left (file ++ " was not specified as input (see shellcheck -x).")
 
       where
@@ -324,49 +288,13 @@ ioInterface options files = do
         fallback path _ = return path
 
 inputFile file = do
-    (handle, shouldCache) <-
+    contents <-
             if file == "-"
-            then return (stdin, True)
-            else do
-                h <- openBinaryFile file ReadMode
-                reopenable <- hIsSeekable h
-                return (h, not reopenable)
-
-    hSetBinaryMode handle True
-    contents <- decodeString <$> hGetContents handle -- closes handle
+            then getContents
+            else readFile file
 
     seq (length contents) $
-        return (contents, shouldCache)
-
--- Decode a char8 string into a utf8 string, with fallback on
--- ISO-8859-1. This avoids depending on additional libraries.
-decodeString = decode
-  where
-    decode [] = []
-    decode (c:rest) | isAscii c = c : decode rest
-    decode (c:rest) =
-        let num = (fromIntegral $ ord c) :: Int
-            next = case num of
-                _ | num >= 0xF8 -> Nothing
-                  | num >= 0xF0 -> construct (num .&. 0x07) 3 rest
-                  | num >= 0xE0 -> construct (num .&. 0x0F) 2 rest
-                  | num >= 0xC0 -> construct (num .&. 0x1F) 1 rest
-                  | True -> Nothing
-        in
-            case next of
-                Just (n, remainder) -> chr n : decode remainder
-                Nothing -> c : decode rest
-
-    construct x 0 rest = do
-        guard $ x <= 0x10FFFF
-        return (x, rest)
-    construct x n (c:rest) =
-        let num = (fromIntegral $ ord c) :: Int in
-            if num >= 0x80 && num <= 0xBF
-            then construct ((x `shiftL` 6) .|. (num .&. 0x3f)) (n-1) rest
-            else Nothing
-    construct _ _ _ = Nothing
-
+        return contents
 
 verifyFiles files =
     when (null files) $ do

stack.yaml

@@ -2,7 +2,7 @@
 # For more information, see: http://docs.haskellstack.org/en/stable/yaml_configuration/
 
 # Specifies the GHC version and set of packages available (e.g., lts-3.5, nightly-2015-09-21, ghc-7.10.2)
-resolver: lts-8.5
+resolver: lts-5.5
 
 # Local packages, usually specified by relative directory name
 packages:

test/shellcheck.hs

@@ -7,14 +7,12 @@ import qualified ShellCheck.Analytics
 import qualified ShellCheck.AnalyzerLib
 import qualified ShellCheck.Parser
 import qualified ShellCheck.Checks.Commands
-import qualified ShellCheck.Checks.ShellSupport
 
 main = do
     putStrLn "Running ShellCheck tests..."
     results <- sequence [
         ShellCheck.Checker.runTests,
         ShellCheck.Checks.Commands.runTests,
-        ShellCheck.Checks.ShellSupport.runTests,
         ShellCheck.Analytics.runTests,
         ShellCheck.AnalyzerLib.runTests,
         ShellCheck.Parser.runTests