Stable version v0.7.1

This release is dedicated to the board game Pandemic, for teaching us
relevant survival skills like how to stay inside and play board games.

.compile_binaries

@@ -1,9 +1,5 @@
 #!/bin/bash
 
-_cleanup(){
-  rm -rf dist shellcheck || true
-}
-
 build_linux() {
   # Linux Docker image
   name="$DOCKER_BASE"
@@ -23,14 +19,6 @@ build_linux() {
   do 
     cp "shellcheck" "deploy/shellcheck-$tag.linux-x86_64"; 
   done
-
-  # Linux Alpine based Docker image
-  name="$DOCKER_BASE-alpine"
-  DOCKER_BUILDS="$DOCKER_BUILDS $name"
-  sed -e '/DELETE-MARKER/,$d' Dockerfile > Dockerfile.alpine
-  docker build -f Dockerfile.alpine -t "$name:current" .
-  docker run "$name:current" sh -c 'shellcheck --version'
-  _cleanup
 }
 
 build_aarch64() {
@@ -50,33 +38,36 @@ build_armv6hf() {
   do 
     cp "shellcheck" "deploy/shellcheck-$tag.linux-armv6hf"; 
   done
-  _cleanup
 }
 
 build_windows() {
   # Windows .exe
-  docker run --user="$UID" -v "$PWD:/appdata" koalaman/winghc cuib
+  docker run -v "$PWD:/appdata" koalaman/winghc cuib
   for tag in $TAGS
   do 
     cp "dist/build/ShellCheck/shellcheck.exe" "deploy/shellcheck-$tag.exe"; 
   done
-  _cleanup
 }
 
 build_osx() {
-  # Darwin x86_64 static executable
+  # Darwin x86_64 executable
+  brew update
   brew install cabal-install pandoc gnu-tar
-  sudo ln -s /usr/local/bin/gsha512sum /usr/local/bin/sha512sum
-  sudo ln -s /usr/local/bin/gtar /usr/local/bin/tar
+  sudo ln -sf /usr/local/bin/gsha512sum /usr/local/bin/sha512sum
+  sudo ln -sf /usr/local/bin/gtar /usr/local/bin/tar
   export PATH="/usr/local/bin:$PATH"
 
   cabal update
   cabal install --dependencies-only
   cabal build shellcheck
+
+  # Cabal 3 no longer has a predictable output path
+  path="$(find . -name 'shellcheck' -type f -perm +111)"
+  [[ -e "$path" ]]
+
   for tag in $TAGS
   do 
-    cp "dist/build/shellcheck/shellcheck" "deploy/shellcheck-$tag.darwin-x86_64";
+    cp "$path" "deploy/shellcheck-$tag.darwin-x86_64";
   done
-  _cleanup
 }
 

.github_deploy

@@ -0,0 +1,57 @@
+#!/bin/bash
+set -x
+shopt -s extglob
+
+if [[ "$TRAVIS_SECURE_ENV_VARS" != "true" ]]
+then
+  echo >&2 "Missing TRAVIS_SECURE_ENV_VARS. Skipping GitHub deployment."
+  exit 0
+fi
+
+install_deps() {
+  version="2.7.0"  # 2.14.1 fails to overwrite duplicates
+  case "$(uname)" in
+    Linux)
+      sudo apt-get update
+      sudo apt-get install curl
+      curl -L "https://github.com/github/hub/releases/download/v$version/hub-linux-amd64-$version.tgz" | tar xvz --strip-components=1 "hub-linux-amd64-$version/bin/hub"
+      ;;
+    Darwin)
+      curl -L "https://github.com/github/hub/releases/download/v$version/hub-darwin-amd64-$version.tgz" | tar xvz --strip-components=1 "hub-darwin-amd64-$version/bin/hub"
+      ;;
+    *)
+      echo "Unknown: $(uname)"
+      exit 1
+      ;;
+  esac
+
+  hub_path="$PWD/bin/hub"
+  hub() {
+    "$hub_path" "$@"
+  }
+}
+install_deps
+
+export EDITOR="touch"
+
+# Sanity check
+hub release show latest || exit 1
+
+for tag in $TAGS
+do
+  if ! hub release show "$tag"
+  then
+    echo "Creating new release $tag"
+    git show --no-patch  --format='format:%B' > description
+    hub release create -F description "$tag"
+  fi
+
+  files=()
+  for file in deploy/*
+  do
+    [[ $file == *.@(xz|gz|zip) ]] || continue
+    files+=(-a "$file")
+  done
+  hub release edit "${files[@]}" "$tag" || exit 1
+done
+

.multi_arch_docker

@@ -0,0 +1,113 @@
+#!/bin/bash
+# This script builds and deploys multi-architecture docker images from the
+# binaries previously built and deployed to GCS by the Travis pipeline.
+
+if [[ "$TRAVIS_SECURE_ENV_VARS" != "true" ]]
+then
+  echo >&2 "Missing TRAVIS_SECURE_ENV_VARS. Skipping Docker builds."
+  exit 0
+fi
+
+function multi_arch_docker::install_docker_buildx() {
+  # Install up-to-date version of docker, with buildx support.
+  local -r docker_apt_repo='https://download.docker.com/linux/ubuntu'
+  curl -fsSL "${docker_apt_repo}/gpg" | sudo apt-key add -
+  local -r os="$(lsb_release -cs)"
+  sudo add-apt-repository "deb [arch=amd64] $docker_apt_repo $os stable"
+  sudo apt-get update
+  sudo apt-get -y -o Dpkg::Options::="--force-confnew" install docker-ce
+
+  # Enable docker daemon experimental support (for 'pull --platform').
+  local -r config='/etc/docker/daemon.json'
+  if [[ -e "$config" ]]; then
+    sudo sed -i -e 's/{/{ "experimental": true, /' "$config"
+  else
+    echo '{ "experimental": true }' | sudo tee "$config"
+  fi
+  sudo systemctl restart docker
+
+  # Install QEMU multi-architecture support for docker buildx.
+  docker run --rm --privileged multiarch/qemu-user-static --reset -p yes
+
+  # Instantiate docker buildx builder with multi-architecture support.
+  export DOCKER_CLI_EXPERIMENTAL=enabled
+  docker buildx create --name mybuilder
+  docker buildx use mybuilder
+  # Start up buildx and verify that all is OK.
+  docker buildx inspect --bootstrap
+}
+
+# Log in to Docker Hub for deployment.
+function multi_arch_docker::login_to_docker_hub() {
+  echo "$DOCKER_PASSWORD" | docker login -u="$DOCKER_USERNAME" --password-stdin
+}
+
+# Run buildx build and push. Passed in arguments augment the command line.
+function multi_arch_docker::buildx() {
+  mkdir -p /tmp/empty
+  docker buildx build \
+    --platform "${DOCKER_PLATFORMS// /,}" \
+    --push \
+    --progress plain \
+    -f Dockerfile.multi-arch \
+    "$@" \
+    /tmp/empty
+  rmdir /tmp/empty
+}
+
+# Build and push plain and alpine docker images for all tags.
+function multi_arch_docker::build_and_push_all() {
+  for tag in $TAGS; do
+    multi_arch_docker::buildx -t "$DOCKER_BASE:$tag" --build-arg "tag=$tag"
+    multi_arch_docker::buildx -t "$DOCKER_BASE-alpine:$tag" \
+      --build-arg "tag=$tag" --target alpine
+  done
+}
+
+# Test all pushed docker images.
+function multi_arch_docker::test_all() {
+  printf '%s\n' "#!/bin/sh" "echo 'hello world'" > myscript
+
+  for platform in $DOCKER_PLATFORMS; do
+    for tag in $TAGS; do
+      for ext in '-alpine' ''; do
+        image="${DOCKER_BASE}${ext}:${tag}"
+        msg="Testing docker image $image on platform $platform"
+        line="${msg//?/=}"
+        printf '\n%s\n%s\n%s\n' "${line}" "${msg}" "${line}"
+        docker pull -q --platform "$platform" "$image"
+        if [ -n "$ext" ]; then
+          echo -n "Image architecture: "
+          docker run --rm --entrypoint /bin/sh "$image" -c 'uname -m'
+          version=$(docker run --rm "$image" shellcheck --version \
+            | grep 'version:')
+        else
+          version=$(docker run --rm "$image" --version | grep 'version:')
+        fi
+        version=${version/#version: /v}
+        echo "shellcheck version: $version"
+        if [[ ! ("$tag" =~ ^(latest|stable)$) && "$tag" != "$version" ]]; then
+          echo "Version mismatch: shellcheck $version tagged as $tag"
+          exit 1
+        fi
+        if [ -n "$ext" ]; then
+          docker run --rm -v "$PWD:/mnt" -w /mnt "$image" shellcheck myscript
+        else
+          docker run --rm -v "$PWD:/mnt" "$image" myscript
+        fi
+      done
+    done
+  done
+}
+
+function multi_arch_docker::main() {
+  export DOCKER_PLATFORMS='linux/amd64'
+  DOCKER_PLATFORMS+=' linux/arm64'
+  DOCKER_PLATFORMS+=' linux/arm/v6'
+
+  multi_arch_docker::install_docker_buildx
+  multi_arch_docker::login_to_docker_hub
+  multi_arch_docker::build_and_push_all
+  set +x
+  multi_arch_docker::test_all
+}

.travis.yml

@@ -1,51 +1,47 @@
-
-sudo: required
-
-language: sh
+language: shell
+os: linux
 
 services:
   - docker
 
-matrix:
+jobs:
   include:
-    - os: linux
-      env: BUILD=linux
-    - os: linux
-      env: BUILD=windows
-    - os: linux
-      env: BUILD=armv6hf
-    - os: linux
-      env: BUILD=aarch64
-    - os: osx
-      env: BUILD=osx
+    - stage: Build
 
+      # This must weirdly not have a dash, otherwise an empty job is created
+      env: BUILD=linux
+    - env: BUILD=windows
+    - env: BUILD=armv6hf
+    - env: BUILD=aarch64
+    - env: BUILD=osx
+      os: osx
+
+    - stage: Deploy docker image
+      # Deploy only for pushes to master branch, not other branches, not PRs.
+      if: type = push
+      script:
+        - source ./.multi_arch_docker
+        - set -ex; multi_arch_docker::main; set +x
+
+# This is in global context and runs for every stage that doesn't override it.
 before_install: |
   DOCKER_BASE="$DOCKER_USERNAME/shellcheck"
   DOCKER_BUILDS=""
-  TAGS=""
+  export TAGS=""
   test "$TRAVIS_BRANCH" = master && TAGS="$TAGS latest" || true
   test -n "$TRAVIS_TAG"          && TAGS="$TAGS stable $TRAVIS_TAG" || true
   echo "Tags are $TAGS"
 
+# This is in global context and runs for every stage that doesn't override it.
 script:
   - mkdir -p deploy
   - source ./.compile_binaries
   - ./striptests
-  - set -x; build_"$BUILD"; set +x;
+  - set -ex; build_"$BUILD"; set +x;
   - ./.prepare_deploy
+  - ./.github_deploy
 
-after_success: |
-  if [ "$BUILD" = "linux" ]; then
-    docker login -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" || exit 1;
-        docker push "$repo:$tag" || exit 1;
-      done;
-    done;
-  fi
-
+# This is in global context and runs for every stage that doesn't override it.
 after_failure: |
   id
   pwd
@@ -53,14 +49,16 @@ after_failure: |
   find . -name '*.log' -type f -exec grep "" /dev/null {} +
   find . -ls
 
+# This is in global context and runs for every stage that doesn't override it.
 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
+  bucket: shellcheck-private
+  local_dir: deploy
   on:
     repo: koalaman/shellcheck
+    condition: $TRAVIS_BUILD_STAGE_NAME = Build
     all_branches: true

CHANGELOG.md

@@ -1,3 +1,24 @@
+## v0.7.1 - 2020-04-04
+### Fixed
+- `-f diff` no longer claims that it found more issues when it didn't
+- Known empty variables now correctly trigger SC2086
+- ShellCheck should now be compatible with Cabal 3
+- SC2154 and all command-specific checks now trigger for builtins
+  called with `builtin`
+
+### Added
+- SC1136: Warn about unexpected characters after ]/]]
+- SC2254: Suggest quoting expansions in case statements
+- SC2255: Suggest using `$((..))` in `[ 2*3 -eq 6 ]`
+- SC2256: Warn about translated strings that are known variables
+- SC2257: Warn about arithmetic mutation in redirections
+- SC2258: Warn about trailing commas in for loop elements
+
+### Changed
+- SC2230: 'command -v' suggestion is now off by default (-i deprecate-which)
+- SC1081: Keywords are now correctly parsed case sensitively, with a warning
+
+
 ## v0.7.0 - 2019-07-28
 ### Added
 - Precompiled binaries for macOS and Linux aarch64

Dockerfile

@@ -12,7 +12,7 @@ COPY ShellCheck.cabal ./
 RUN cabal update && cabal install --dependencies-only --ghc-options="-optlo-Os -split-sections"
 
 # Copy source and build it
-COPY LICENSE Setup.hs shellcheck.hs ./
+COPY LICENSE shellcheck.hs ./
 COPY src src
 RUN cabal build Paths_ShellCheck && \
   ghc -optl-static -optl-pthread -isrc -idist/build/autogen --make shellcheck -split-sections -optc-Wl,--gc-sections -optlo-Os && \
@@ -21,13 +21,6 @@ RUN cabal build Paths_ShellCheck && \
 RUN mkdir -p /out/bin && \
   cp shellcheck  /out/bin/
 
-# Resulting Alpine image
-FROM alpine:latest
-LABEL maintainer="Vidar Holen <vidar@vidarholen.net>"
-COPY --from=build /out /
-
-# DELETE-MARKER (Remove everything below to keep the alpine image)
-
 # Resulting ShellCheck image
 FROM scratch
 LABEL maintainer="Vidar Holen <vidar@vidarholen.net>"

Dockerfile.multi-arch

@@ -0,0 +1,26 @@
+# Alpine image
+FROM alpine:latest AS alpine
+LABEL maintainer="Vidar Holen <vidar@vidarholen.net>"
+ARG tag
+
+# Put the right binary for each architecture into place for the
+# multi-architecture docker image.
+RUN set -x; \
+  arch="$(uname -m)"; \
+  echo "arch is $arch"; \
+  if [ "${arch}" = 'armv7l' ]; then \
+    arch='armv6hf'; \
+  fi; \
+  url_base='https://github.com/koalaman/shellcheck/releases/download/'; \
+  tar_file="${tag}/shellcheck-${tag}.linux.${arch}.tar.xz"; \
+  wget "${url_base}${tar_file}" -O - | tar xJf -; \
+  mv "shellcheck-${tag}/shellcheck" /bin/; \
+  rm -rf "shellcheck-${tag}"; \
+  ls -laF /bin/shellcheck
+
+# ShellCheck image
+FROM scratch
+LABEL maintainer="Vidar Holen <vidar@vidarholen.net>"
+WORKDIR /mnt
+COPY --from=alpine /bin/shellcheck /bin/
+ENTRYPOINT ["/bin/shellcheck"]

README.md

@@ -109,6 +109,7 @@ Services and platforms that have ShellCheck pre-installed and ready to use:
 * [Codacy](https://www.codacy.com/)
 * [Code Climate](https://codeclimate.com/)
 * [Code Factor](https://www.codefactor.io/)
+* [Github](https://github.com/features/actions)(only Linux)
 
 Services and platforms with third party plugins:
 
@@ -116,7 +117,7 @@ Services and platforms with third party plugins:
 
 Most other services, including [GitLab](https://about.gitlab.com/), let you install
 ShellCheck yourself, either through the system's package manager (see [Installing](#installing)),
-or by downloading and unpacking a [binary release](#installing-the-shellcheck-binary).
+or by downloading and unpacking a [binary release](#installing-a-pre-compiled-binary).
 
 It's a good idea to manually install a specific ShellCheck version regardless. This avoids
 any surprise build breaks when a new version with new warnings is published.
@@ -209,15 +210,21 @@ docker run --rm -v "$PWD:/mnt" koalaman/shellcheck:stable myscript
 
 or use `koalaman/shellcheck-alpine` if you want a larger Alpine Linux based image to extend. It works exactly like a regular Alpine image, but has shellcheck preinstalled.
 
+Using the [nix package manager](https://nixos.org/nix):
+```sh
+nix-env -iA nixpkgs.shellcheck
+```
+
 Alternatively, you can download pre-compiled binaries for the latest release here:
 
-* [Linux, x86_64](https://storage.googleapis.com/shellcheck/shellcheck-stable.linux.x86_64.tar.xz) (statically linked)
-* [Linux, armv6hf](https://storage.googleapis.com/shellcheck/shellcheck-stable.linux.armv6hf.tar.xz), i.e. Raspberry Pi (statically linked)
-* [Linux, aarch64](https://storage.googleapis.com/shellcheck/shellcheck-stable.linux.armv6hf.tar.xz) aka ARM64 (statically linked)
-* [MacOS, x86_64](https://shellcheck.storage.googleapis.com/shellcheck-stable.darwin.x86_64.tar.xz)
-* [Windows, x86](https://storage.googleapis.com/shellcheck/shellcheck-stable.zip)
+* [Linux, x86_64](https://github.com/koalaman/shellcheck/releases/download/stable/shellcheck-stable.linux.x86_64.tar.xz) (statically linked)
+* [Linux, armv6hf](https://github.com/koalaman/shellcheck/releases/download/stable/shellcheck-stable.linux.armv6hf.tar.xz), i.e. Raspberry Pi (statically linked)
+* [Linux, aarch64](https://github.com/koalaman/shellcheck/releases/download/stable/shellcheck-stable.linux.aarch64.tar.xz) aka ARM64 (statically linked)
+* [MacOS, x86_64](https://github.com/koalaman/shellcheck/releases/download/stable/shellcheck-stable.darwin.x86_64.tar.xz)
+* [Windows, x86](https://github.com/koalaman/shellcheck/releases/download/stable/shellcheck-stable.zip)
 
-or see the [storage bucket listing](https://shellcheck.storage.googleapis.com/index.html) for checksums, older versions and the latest daily builds.
+or see the [GitHub Releases](https://github.com/koalaman/shellcheck/releases) for other releases
+(including the [latest](https://github.com/koalaman/shellcheck/releases/tag/latest) meta-release for daily git builds).
 
 Distro packages already come with a `man` page. If you are building from source, it can be installed with:
 
@@ -244,7 +251,7 @@ A simple installer may do something like:
 
 ```bash
 scversion="stable" # or "v0.4.7", or "latest"
-wget -qO- "https://storage.googleapis.com/shellcheck/shellcheck-${scversion?}.linux.x86_64.tar.xz" | tar -xJv
+wget -qO- "https://github.com/koalaman/shellcheck/releases/download/${scversion?}/shellcheck-${scversion?}.linux.x86_64.tar.xz" | tar -xJv
 cp "shellcheck-${scversion}/shellcheck" /usr/bin/
 shellcheck --version
 ```

Setup.hs

@@ -1,36 +0,0 @@
-import Distribution.PackageDescription (
-  HookedBuildInfo,
-  emptyHookedBuildInfo )
-import Distribution.Simple (
-  Args,
-  UserHooks ( preSDist ),
-  defaultMainWithHooks,
-  simpleUserHooks )
-import Distribution.Simple.Setup ( SDistFlags )
-
-import System.Process ( system )
-
-
-main = defaultMainWithHooks myHooks
-  where
-    myHooks = simpleUserHooks { preSDist = myPreSDist }
-
--- | This hook will be executed before e.g. @cabal sdist@. It runs
---   pandoc to create the man page from shellcheck.1.md. If the pandoc
---   command is not found, this will fail with an error message:
---
---     /bin/sh: pandoc: command not found
---
---   Since the man page is listed in the Extra-Source-Files section of
---   our cabal file, a failure here should result in a failure to
---   create the distribution tarball (that's a good thing).
---
-myPreSDist :: Args -> SDistFlags -> IO HookedBuildInfo
-myPreSDist _ _ = do
-  putStrLn "Building the man page (shellcheck.1) with pandoc..."
-  putStrLn pandoc_cmd
-  result <- system pandoc_cmd
-  putStrLn $ "pandoc exited with " ++ show result
-  return emptyHookedBuildInfo
-  where
-    pandoc_cmd = "pandoc -s -f markdown-smart -t man shellcheck.1.md -o shellcheck.1"

ShellCheck.cabal

@@ -1,5 +1,5 @@
 Name:             ShellCheck
-Version:          0.7.0
+Version:          0.7.1
 Synopsis:         Shell script analysis tool
 License:          GPL-3
 License-file:     LICENSE
@@ -7,7 +7,7 @@ Category:         Static Analysis
 Author:           Vidar Holen
 Maintainer:       vidar@vidarholen.net
 Homepage:         https://www.shellcheck.net/
-Build-Type:       Custom
+Build-Type:       Simple
 Cabal-Version:    >= 1.8
 Bug-reports:      https://github.com/koalaman/shellcheck/issues
 Description:
@@ -26,19 +26,13 @@ Extra-Source-Files:
     -- documentation
     README.md
     shellcheck.1.md
-    -- built with a cabal sdist hook
-    shellcheck.1
+    -- A script to build the man page using pandoc
+    manpage
     -- convenience script for stripping tests
     striptests
     -- tests
     test/shellcheck.hs
 
-custom-setup
-  setup-depends:
-    base    >= 4    && <5,
-    process >= 1.0  && <1.7,
-    Cabal   >= 1.10 && <2.5
-
 source-repository head
     type: git
     location: git://github.com/koalaman/shellcheck.git
@@ -51,9 +45,7 @@ library
     build-depends:
       aeson,
       array,
-      -- GHC 7.6.3 (base 4.6.0.1) is buggy (#1131, #1119) in optimized mode.
-      -- Just disable that version entirely to fail fast.
-      base > 4.6.0.1 && < 5,
+      base >= 4.8.0.0 && < 5,
       bytestring,
       containers >= 0.5,
       deepseq >= 1.4.0.0,

manpage

@@ -0,0 +1,4 @@
+#!/bin/sh
+echo >&2 "Generating man page using pandoc"
+pandoc -s -f markdown-smart -t man shellcheck.1.md -o shellcheck.1 || exit
+echo >&2 "Done. You can read it with:   man ./shellcheck.1"

nextnumber

@@ -8,6 +8,6 @@ fi
 
 for i in 1 2
 do
-  last=$(grep -hv "^prop" ./**/*.hs | grep -Ewo "$i[0-9]{3}" | sort -n | tail -n 1)
+  last=$(grep -hv "^prop" ./**/*.hs | grep -Ewo "${i}[0-9]{3}" | sort -n | tail -n 1)
   echo "Next ${i}xxx: $((last+1))"
 done

shellcheck.1.md

@@ -107,7 +107,7 @@ not warn at all, as `ksh` supports decimals in arithmetic contexts.
 
 **-x**,\ **--external-sources**
 
-:   Follow 'source' statements even when the file is not specified as input.
+:   Follow `source` statements even when the file is not specified as input.
     By default, `shellcheck` will only follow files specified on the command
     line (plus `/dev/null`). This option allows following any file the script
     may `source`.
@@ -275,8 +275,8 @@ Here is an example `.shellcheckrc`:
     # Turn on warnings for unassigned uppercase variables
     enable=check-unassigned-uppercase
 
-    # Allow using `which` since it gives full paths and is common enough
-    disable=SC2230
+    # Allow [ ! -z foo ] instead of suggesting -n
+    disable=SC2236
 
 If no `.shellcheckrc` is found in any of the parent directories, ShellCheck
 will look in `~/.shellcheckrc` followed by the XDG config directory
@@ -301,7 +301,7 @@ invocation.
 
 # RETURN VALUES
 
-ShellCheck uses the follow exit codes:
+ShellCheck uses the following exit codes:
 
 + 0: All files successfully scanned with no issues.
 + 1: All files successfully scanned with some issues.

shellcheck.hs

@@ -491,6 +491,12 @@ ioInterface options files = do
         first <- a arg
         if not first then return False else b arg
 
+    findM p = foldr go (pure Nothing)
+      where
+        go x acc = do
+            b <- p x
+            if b then pure (Just x) else acc
+
     findSourceFile inputs sourcePathFlag currentScript sourcePathAnnotation original =
         if isAbsolute original
         then
@@ -500,11 +506,11 @@ ioInterface options files = do
             find original original
       where
         find filename deflt = do
-            sources <- filterM ((allowable inputs) `andM` doesFileExist) $
+            sources <- findM ((allowable inputs) `andM` doesFileExist) $
                         (adjustPath filename):(map (</> filename) $ map adjustPath $ sourcePathFlag ++ sourcePathAnnotation)
             case sources of
-                [] -> return deflt
-                (first:_) -> return first
+                Nothing -> return deflt
+                Just first -> return first
         scriptdir = dropFileName currentScript
         adjustPath str =
             case (splitDirectories str) of

src/ShellCheck/AST.hs

@@ -17,7 +17,7 @@
     You should have received a copy of the GNU General Public License
     along with this program.  If not, see <https://www.gnu.org/licenses/>.
 -}
-{-# LANGUAGE DeriveGeneric, DeriveAnyClass #-}
+{-# LANGUAGE DeriveGeneric, DeriveAnyClass, DeriveTraversable, PatternSynonyms #-}
 module ShellCheck.AST where
 
 import GHC.Generics (Generic)
@@ -37,110 +37,112 @@ newtype 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
-    | TA_Variable Id String [Token]
-    | TA_Expansion Id [Token]
-    | TA_Sequence Id [Token]
-    | TA_Trinary Id Token Token Token
-    | TA_Unary Id String 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_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_Arithmetic Id Token
-    | T_Array Id [Token]
-    | T_IndexedElement Id [Token] Token
+data Token = OuterToken Id (InnerToken Token) deriving (Show)
+
+data InnerToken t =
+    Inner_TA_Binary String t t
+    | Inner_TA_Assignment String t t
+    | Inner_TA_Variable String [t]
+    | Inner_TA_Expansion [t]
+    | Inner_TA_Sequence [t]
+    | Inner_TA_Trinary t t t
+    | Inner_TA_Unary String t
+    | Inner_TC_And ConditionType String t t
+    | Inner_TC_Binary ConditionType String t t
+    | Inner_TC_Group ConditionType t
+    | Inner_TC_Nullary ConditionType t
+    | Inner_TC_Or ConditionType String t t
+    | Inner_TC_Unary ConditionType String t
+    | Inner_TC_Empty ConditionType
+    | Inner_T_AND_IF
+    | Inner_T_AndIf t t
+    | Inner_T_Arithmetic t
+    | Inner_T_Array [t]
+    | Inner_T_IndexedElement [t] t
     -- 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_Backgrounded Id Token
-    | T_Backticked Id [Token]
-    | T_Bang Id
-    | T_Banged Id Token
-    | T_BraceExpansion Id [Token]
-    | T_BraceGroup Id [Token]
-    | T_CLOBBER Id
-    | T_Case Id
-    | T_CaseExpression Id Token [(CaseType, [Token], [Token])]
-    | T_Condition Id ConditionType Token
-    | T_DGREAT Id
-    | T_DLESS Id
-    | T_DLESSDASH Id
-    | T_DSEMI Id
-    | T_Do Id
-    | T_DollarArithmetic Id Token
-    | T_DollarBraced Id Bool Token
-    | T_DollarBracket Id Token
-    | T_DollarDoubleQuoted Id [Token]
-    | T_DollarExpansion Id [Token]
-    | T_DollarSingleQuoted Id String
-    | T_DollarBraceCommandExpansion Id [Token]
-    | T_Done Id
-    | T_DoubleQuoted Id [Token]
-    | T_EOF Id
-    | T_Elif Id
-    | T_Else Id
-    | T_Esac Id
-    | T_Extglob Id String [Token]
-    | T_FdRedirect Id String Token
-    | T_Fi Id
-    | T_For Id
-    | T_ForArithmetic Id Token Token Token [Token]
-    | T_ForIn Id String [Token] [Token]
-    | T_Function Id FunctionKeyword FunctionParentheses String Token
-    | T_GREATAND Id
-    | T_Glob Id String
-    | T_Greater Id
-    | T_HereDoc Id Dashed Quoted String [Token]
-    | T_HereString Id Token
-    | T_If Id
-    | 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
-    | T_Less Id
-    | T_Literal Id String
-    | T_Lparen Id
-    | 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_Pipeline Id [Token] [Token] -- [Pipe separators] [Commands]
-    | T_ProcSub Id String [Token]
-    | T_Rbrace Id
-    | T_Redirecting Id [Token] Token
-    | T_Rparen Id
-    | T_Script Id Token [Token] -- Shebang T_Literal, followed by script.
-    | T_Select Id
-    | T_SelectIn Id String [Token] [Token]
-    | T_Semi Id
-    | T_SimpleCommand Id [Token] [Token]
-    | T_SingleQuoted Id String
-    | T_Subshell Id [Token]
-    | T_Then Id
-    | T_Until Id
-    | T_UntilExpression Id [Token] [Token]
-    | T_While Id
-    | T_WhileExpression Id [Token] [Token]
-    | T_Annotation Id [Annotation] Token
-    | T_Pipe Id String
-    | T_CoProc Id (Maybe String) Token
-    | T_CoProcBody Id Token
-    | T_Include Id Token
-    | T_SourceCommand Id Token Token
-    | T_BatsTest Id Token Token
-    deriving (Show)
+    | Inner_T_UnparsedIndex SourcePos String
+    | Inner_T_Assignment AssignmentMode String [t] t
+    | Inner_T_Backgrounded t
+    | Inner_T_Backticked [t]
+    | Inner_T_Bang
+    | Inner_T_Banged t
+    | Inner_T_BraceExpansion [t]
+    | Inner_T_BraceGroup [t]
+    | Inner_T_CLOBBER
+    | Inner_T_Case
+    | Inner_T_CaseExpression t [(CaseType, [t], [t])]
+    | Inner_T_Condition ConditionType t
+    | Inner_T_DGREAT
+    | Inner_T_DLESS
+    | Inner_T_DLESSDASH
+    | Inner_T_DSEMI
+    | Inner_T_Do
+    | Inner_T_DollarArithmetic t
+    | Inner_T_DollarBraced Bool t
+    | Inner_T_DollarBracket t
+    | Inner_T_DollarDoubleQuoted [t]
+    | Inner_T_DollarExpansion [t]
+    | Inner_T_DollarSingleQuoted String
+    | Inner_T_DollarBraceCommandExpansion [t]
+    | Inner_T_Done
+    | Inner_T_DoubleQuoted [t]
+    | Inner_T_EOF
+    | Inner_T_Elif
+    | Inner_T_Else
+    | Inner_T_Esac
+    | Inner_T_Extglob String [t]
+    | Inner_T_FdRedirect String t
+    | Inner_T_Fi
+    | Inner_T_For
+    | Inner_T_ForArithmetic t t t [t]
+    | Inner_T_ForIn String [t] [t]
+    | Inner_T_Function FunctionKeyword FunctionParentheses String t
+    | Inner_T_GREATAND
+    | Inner_T_Glob String
+    | Inner_T_Greater
+    | Inner_T_HereDoc Dashed Quoted String [t]
+    | Inner_T_HereString t
+    | Inner_T_If
+    | Inner_T_IfExpression [([t],[t])] [t]
+    | Inner_T_In
+    | Inner_T_IoFile t t
+    | Inner_T_IoDuplicate t String
+    | Inner_T_LESSAND
+    | Inner_T_LESSGREAT
+    | Inner_T_Lbrace
+    | Inner_T_Less
+    | Inner_T_Literal String
+    | Inner_T_Lparen
+    | Inner_T_NEWLINE
+    | Inner_T_NormalWord [t]
+    | Inner_T_OR_IF
+    | Inner_T_OrIf t t
+    | Inner_T_ParamSubSpecialChar String -- e.g. '%' in ${foo%bar}  or '/' in ${foo/bar/baz}
+    | Inner_T_Pipeline [t] [t] -- [Pipe separators] [Commands]
+    | Inner_T_ProcSub String [t]
+    | Inner_T_Rbrace
+    | Inner_T_Redirecting [t] t
+    | Inner_T_Rparen
+    | Inner_T_Script t [t] -- Shebang T_Literal, followed by script.
+    | Inner_T_Select
+    | Inner_T_SelectIn String [t] [t]
+    | Inner_T_Semi
+    | Inner_T_SimpleCommand [t] [t]
+    | Inner_T_SingleQuoted String
+    | Inner_T_Subshell [t]
+    | Inner_T_Then
+    | Inner_T_Until
+    | Inner_T_UntilExpression [t] [t]
+    | Inner_T_While
+    | Inner_T_WhileExpression [t] [t]
+    | Inner_T_Annotation [Annotation] t
+    | Inner_T_Pipe String
+    | Inner_T_CoProc (Maybe String) t
+    | Inner_T_CoProcBody t
+    | Inner_T_Include t
+    | Inner_T_SourceCommand t t
+    | Inner_T_BatsTest t t
+    deriving (Show, Eq, Functor, Foldable, Traversable)
 
 data Annotation =
     DisableComment Integer
@@ -151,240 +153,125 @@ data Annotation =
     deriving (Show, Eq)
 data ConditionType = DoubleBracket | SingleBracket deriving (Show, Eq)
 
--- This is an abomination.
-tokenEquals :: Token -> Token -> Bool
-tokenEquals a b = kludge a == kludge b
-    where kludge s = Re.subRegex (Re.mkRegex "\\(Id [0-9]+\\)") (show s) "(Id 0)"
+pattern T_AND_IF id = OuterToken id Inner_T_AND_IF
+pattern T_Bang id = OuterToken id Inner_T_Bang
+pattern T_Case id = OuterToken id Inner_T_Case
+pattern TC_Empty id typ = OuterToken id (Inner_TC_Empty typ)
+pattern T_CLOBBER id = OuterToken id Inner_T_CLOBBER
+pattern T_DGREAT id = OuterToken id Inner_T_DGREAT
+pattern T_DLESS id = OuterToken id Inner_T_DLESS
+pattern T_DLESSDASH id = OuterToken id Inner_T_DLESSDASH
+pattern T_Do id = OuterToken id Inner_T_Do
+pattern T_DollarSingleQuoted id str = OuterToken id (Inner_T_DollarSingleQuoted str)
+pattern T_Done id = OuterToken id Inner_T_Done
+pattern T_DSEMI id = OuterToken id Inner_T_DSEMI
+pattern T_Elif id = OuterToken id Inner_T_Elif
+pattern T_Else id = OuterToken id Inner_T_Else
+pattern T_EOF id = OuterToken id Inner_T_EOF
+pattern T_Esac id = OuterToken id Inner_T_Esac
+pattern T_Fi id = OuterToken id Inner_T_Fi
+pattern T_For id = OuterToken id Inner_T_For
+pattern T_Glob id str = OuterToken id (Inner_T_Glob str)
+pattern T_GREATAND id = OuterToken id Inner_T_GREATAND
+pattern T_Greater id = OuterToken id Inner_T_Greater
+pattern T_If id = OuterToken id Inner_T_If
+pattern T_In id = OuterToken id Inner_T_In
+pattern T_Lbrace id = OuterToken id Inner_T_Lbrace
+pattern T_Less id = OuterToken id Inner_T_Less
+pattern T_LESSAND id = OuterToken id Inner_T_LESSAND
+pattern T_LESSGREAT id = OuterToken id Inner_T_LESSGREAT
+pattern T_Literal id str = OuterToken id (Inner_T_Literal str)
+pattern T_Lparen id = OuterToken id Inner_T_Lparen
+pattern T_NEWLINE id = OuterToken id Inner_T_NEWLINE
+pattern T_OR_IF id = OuterToken id Inner_T_OR_IF
+pattern T_ParamSubSpecialChar id str = OuterToken id (Inner_T_ParamSubSpecialChar str)
+pattern T_Pipe id str = OuterToken id (Inner_T_Pipe str)
+pattern T_Rbrace id = OuterToken id Inner_T_Rbrace
+pattern T_Rparen id = OuterToken id Inner_T_Rparen
+pattern T_Select id = OuterToken id Inner_T_Select
+pattern T_Semi id = OuterToken id Inner_T_Semi
+pattern T_SingleQuoted id str = OuterToken id (Inner_T_SingleQuoted str)
+pattern T_Then id = OuterToken id Inner_T_Then
+pattern T_UnparsedIndex id pos str = OuterToken id (Inner_T_UnparsedIndex pos str)
+pattern T_Until id = OuterToken id Inner_T_Until
+pattern T_While id = OuterToken id Inner_T_While
+pattern TA_Assignment id op t1 t2 = OuterToken id (Inner_TA_Assignment op t1 t2)
+pattern TA_Binary id op t1 t2 = OuterToken id (Inner_TA_Binary op t1 t2)
+pattern TA_Expansion id t = OuterToken id (Inner_TA_Expansion t)
+pattern T_AndIf id t u = OuterToken id (Inner_T_AndIf t u)
+pattern T_Annotation id anns t = OuterToken id (Inner_T_Annotation anns t)
+pattern T_Arithmetic id c = OuterToken id (Inner_T_Arithmetic c)
+pattern T_Array id t = OuterToken id (Inner_T_Array t)
+pattern TA_Sequence id l = OuterToken id (Inner_TA_Sequence l)
+pattern T_Assignment id mode var indices value = OuterToken id (Inner_T_Assignment mode var indices value)
+pattern TA_Trinary id t1 t2 t3 = OuterToken id (Inner_TA_Trinary t1 t2 t3)
+pattern TA_Unary id op t1 = OuterToken id (Inner_TA_Unary op t1)
+pattern TA_Variable id str t = OuterToken id (Inner_TA_Variable str t)
+pattern T_Backgrounded id l = OuterToken id (Inner_T_Backgrounded l)
+pattern T_Backticked id list = OuterToken id (Inner_T_Backticked list)
+pattern T_Banged id l = OuterToken id (Inner_T_Banged l)
+pattern T_BatsTest id name t = OuterToken id (Inner_T_BatsTest name t)
+pattern T_BraceExpansion id list = OuterToken id (Inner_T_BraceExpansion list)
+pattern T_BraceGroup id l = OuterToken id (Inner_T_BraceGroup l)
+pattern TC_And id typ str t1 t2 = OuterToken id (Inner_TC_And typ str t1 t2)
+pattern T_CaseExpression id word cases = OuterToken id (Inner_T_CaseExpression word cases)
+pattern TC_Binary id typ op lhs rhs = OuterToken id (Inner_TC_Binary typ op lhs rhs)
+pattern TC_Group id typ token = OuterToken id (Inner_TC_Group typ token)
+pattern TC_Nullary id typ token = OuterToken id (Inner_TC_Nullary typ token)
+pattern T_Condition id typ token = OuterToken id (Inner_T_Condition typ token)
+pattern T_CoProcBody id t = OuterToken id (Inner_T_CoProcBody t)
+pattern T_CoProc id var body = OuterToken id (Inner_T_CoProc var body)
+pattern TC_Or id typ str t1 t2 = OuterToken id (Inner_TC_Or typ str t1 t2)
+pattern TC_Unary id typ op token = OuterToken id (Inner_TC_Unary typ op token)
+pattern T_DollarArithmetic id c = OuterToken id (Inner_T_DollarArithmetic c)
+pattern T_DollarBraceCommandExpansion id list = OuterToken id (Inner_T_DollarBraceCommandExpansion list)
+pattern T_DollarBraced id braced op = OuterToken id (Inner_T_DollarBraced braced op)
+pattern T_DollarBracket id c = OuterToken id (Inner_T_DollarBracket c)
+pattern T_DollarDoubleQuoted id list = OuterToken id (Inner_T_DollarDoubleQuoted list)
+pattern T_DollarExpansion id list = OuterToken id (Inner_T_DollarExpansion list)
+pattern T_DoubleQuoted id list = OuterToken id (Inner_T_DoubleQuoted list)
+pattern T_Extglob id str l = OuterToken id (Inner_T_Extglob str l)
+pattern T_FdRedirect id v t = OuterToken id (Inner_T_FdRedirect v t)
+pattern T_ForArithmetic id a b c group = OuterToken id (Inner_T_ForArithmetic a b c group)
+pattern T_ForIn id v w l = OuterToken id (Inner_T_ForIn v w l)
+pattern T_Function id a b name body = OuterToken id (Inner_T_Function a b name body)
+pattern T_HereDoc id d q str l = OuterToken id (Inner_T_HereDoc d q str l)
+pattern T_HereString id word = OuterToken id (Inner_T_HereString word)
+pattern T_IfExpression id conditions elses = OuterToken id (Inner_T_IfExpression conditions elses)
+pattern T_Include id script = OuterToken id (Inner_T_Include script)
+pattern T_IndexedElement id indices t = OuterToken id (Inner_T_IndexedElement indices t)
+pattern T_IoDuplicate id op num = OuterToken id (Inner_T_IoDuplicate op num)
+pattern T_IoFile id op file = OuterToken id (Inner_T_IoFile op file)
+pattern T_NormalWord id list = OuterToken id (Inner_T_NormalWord list)
+pattern T_OrIf id t u = OuterToken id (Inner_T_OrIf t u)
+pattern T_Pipeline id l1 l2 = OuterToken id (Inner_T_Pipeline l1 l2)
+pattern T_ProcSub id typ l = OuterToken id (Inner_T_ProcSub typ l)
+pattern T_Redirecting id redirs cmd = OuterToken id (Inner_T_Redirecting redirs cmd)
+pattern T_Script id shebang list = OuterToken id (Inner_T_Script shebang list)
+pattern T_SelectIn id v w l = OuterToken id (Inner_T_SelectIn v w l)
+pattern T_SimpleCommand id vars cmds = OuterToken id (Inner_T_SimpleCommand vars cmds)
+pattern T_SourceCommand id includer t_include = OuterToken id (Inner_T_SourceCommand includer t_include)
+pattern T_Subshell id l = OuterToken id (Inner_T_Subshell l)
+pattern T_UntilExpression id c l = OuterToken id (Inner_T_UntilExpression c l)
+pattern T_WhileExpression id c l = OuterToken id (Inner_T_WhileExpression c l)
+
+{-# COMPLETE T_AND_IF, T_Bang, T_Case, TC_Empty, T_CLOBBER, T_DGREAT, T_DLESS, T_DLESSDASH, T_Do, T_DollarSingleQuoted, T_Done, T_DSEMI, T_Elif, T_Else, T_EOF, T_Esac, T_Fi, T_For, T_Glob, T_GREATAND, T_Greater, T_If, T_In, T_Lbrace, T_Less, T_LESSAND, T_LESSGREAT, T_Literal, T_Lparen, T_NEWLINE, T_OR_IF, T_ParamSubSpecialChar, T_Pipe, T_Rbrace, T_Rparen, T_Select, T_Semi, T_SingleQuoted, T_Then, T_UnparsedIndex, T_Until, T_While, TA_Assignment, TA_Binary, TA_Expansion, T_AndIf, T_Annotation, T_Arithmetic, T_Array, TA_Sequence, T_Assignment, TA_Trinary, TA_Unary, TA_Variable, T_Backgrounded, T_Backticked, T_Banged, T_BatsTest, T_BraceExpansion, T_BraceGroup, TC_And, T_CaseExpression, TC_Binary, TC_Group, TC_Nullary, T_Condition, T_CoProcBody, T_CoProc, TC_Or, TC_Unary, T_DollarArithmetic, T_DollarBraceCommandExpansion, T_DollarBraced, T_DollarBracket, T_DollarDoubleQuoted, T_DollarExpansion, T_DoubleQuoted, T_Extglob, T_FdRedirect, T_ForArithmetic, T_ForIn, T_Function, T_HereDoc, T_HereString, T_IfExpression, T_Include, T_IndexedElement, T_IoDuplicate, T_IoFile, T_NormalWord, T_OrIf, T_Pipeline, T_ProcSub, T_Redirecting, T_Script, T_SelectIn, T_SimpleCommand, T_SourceCommand, T_Subshell, T_UntilExpression, T_WhileExpression #-}
 
 instance Eq Token where
-    (==) = tokenEquals
+    OuterToken _ a == OuterToken _ b = a == b
 
 analyze :: Monad m => (Token -> m ()) -> (Token -> m ()) -> (Token -> m Token) -> Token -> m Token
 analyze f g i =
     round
   where
-    round t = do
+    round t@(OuterToken id it) = do
         f t
-        newT <- delve t
+        newIt <- traverse round it
         g t
-        i newT
-    roundAll = mapM round
-
-    dl l v = do
-        x <- roundAll l
-        return $ v x
-    dll l m v = do
-        x <- roundAll l
-        y <- roundAll m
-        return $ v x y
-    d1 t v = do
-        x <- round t
-        return $ v x
-    d2 t1 t2 v = do
-        x <- round t1
-        y <- round t2
-        return $ v x y
-
-    delve (T_NormalWord id list) = dl list $ T_NormalWord id
-    delve (T_DoubleQuoted id list) = dl list $ T_DoubleQuoted id
-    delve (T_DollarDoubleQuoted id list) = dl list $ T_DollarDoubleQuoted id
-    delve (T_DollarExpansion id list) = dl list $ T_DollarExpansion id
-    delve (T_DollarBraceCommandExpansion id list) = dl list $ T_DollarBraceCommandExpansion id
-    delve (T_BraceExpansion id list) = dl list $ T_BraceExpansion id
-    delve (T_Backticked id list) = dl list $ T_Backticked id
-    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
-        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_Redirecting id redirs cmd) = do
-        a <- roundAll redirs
-        b <- round cmd
-        return $ T_Redirecting id a b
-    delve (T_SimpleCommand id vars cmds) = dll vars cmds $ T_SimpleCommand id
-    delve (T_Pipeline id l1 l2) = dll l1 l2 $ T_Pipeline id
-    delve (T_Banged id l) = d1 l $ T_Banged id
-    delve (T_AndIf id t u) = d2 t u $ T_AndIf id
-    delve (T_OrIf id t u) = d2 t u $ T_OrIf id
-    delve (T_Backgrounded id l) = d1 l $ T_Backgrounded id
-    delve (T_Subshell id l) = dl l $ T_Subshell id
-    delve (T_ProcSub id typ l) = dl l $ T_ProcSub id typ
-    delve (T_Arithmetic id c) = d1 c $ T_Arithmetic id
-    delve (T_IfExpression id conditions elses) = do
-        newConds <- mapM (\(c, t) -> do
-                            x <- mapM round c
-                            y <- mapM round t
-                            return (x,y)
-                    ) conditions
-        newElses <- roundAll elses
-        return $ T_IfExpression id newConds newElses
-    delve (T_BraceGroup id l) = dl l $ T_BraceGroup id
-    delve (T_WhileExpression id c l) = dll c l $ T_WhileExpression id
-    delve (T_UntilExpression id c l) = dll c l $ T_UntilExpression id
-    delve (T_ForIn id v w l) = dll w l $ T_ForIn id v
-    delve (T_SelectIn id v w l) = dll w l $ T_SelectIn id v
-    delve (T_CaseExpression id word cases) = do
-        newWord <- round word
-        newCases <- mapM (\(o, c, t) -> do
-                            x <- mapM round c
-                            y <- mapM round t
-                            return (o, x,y)
-                        ) cases
-        return $ T_CaseExpression id newWord newCases
-
-    delve (T_ForArithmetic id a b c group) = do
-        x <- round a
-        y <- round b
-        z <- round c
-        list <- mapM round group
-        return $ T_ForArithmetic id x y z list
-
-    delve (T_Script id s l) = dl l $ T_Script id s
-    delve (T_Function id a b name body) = d1 body $ T_Function id a b name
-    delve (T_Condition id typ token) = d1 token $ T_Condition id typ
-    delve (T_Extglob id str l) = dl l $ T_Extglob id str
-    delve (T_DollarBraced id braced op) = d1 op $ T_DollarBraced id braced
-    delve (T_HereDoc id d q str l) = dl l $ T_HereDoc id d q str
-
-    delve (TC_And id typ str t1 t2) = d2 t1 t2 $ TC_And id typ str
-    delve (TC_Or id typ str t1 t2) = d2 t1 t2 $ TC_Or id typ str
-    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 (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
-    delve (TA_Unary id op t1) = d1 t1 $ TA_Unary id op
-    delve (TA_Sequence id l) = dl l $ TA_Sequence id
-    delve (TA_Trinary id t1 t2 t3) = do
-        a <- round t1
-        b <- round t2
-        c <- round t3
-        return $ TA_Trinary id a b c
-    delve (TA_Expansion id t) = dl t $ TA_Expansion id
-    delve (TA_Variable id str t) = dl t $ TA_Variable id str
-    delve (T_Annotation id anns t) = d1 t $ T_Annotation id anns
-    delve (T_CoProc id var body) = d1 body $ T_CoProc id var
-    delve (T_CoProcBody id t) = d1 t $ T_CoProcBody id
-    delve (T_Include id script) = d1 script $ T_Include id
-    delve (T_SourceCommand id includer t_include) = d2 includer t_include $ T_SourceCommand id
-    delve (T_BatsTest id name t) = d2 name t $ T_BatsTest id
-    delve t = return t
+        i (OuterToken id newIt)
 
 getId :: Token -> Id
-getId t = case t of
-        T_AND_IF id  -> id
-        T_OR_IF id  -> id
-        T_DSEMI id  -> id
-        T_Semi id  -> id
-        T_DLESS id  -> id
-        T_DGREAT id  -> id
-        T_LESSAND id  -> id
-        T_GREATAND id  -> id
-        T_LESSGREAT id  -> id
-        T_DLESSDASH id  -> id
-        T_CLOBBER id  -> id
-        T_If id  -> id
-        T_Then id  -> id
-        T_Else id  -> id
-        T_Elif id  -> id
-        T_Fi id  -> id
-        T_Do id  -> id
-        T_Done id  -> id
-        T_Case id  -> id
-        T_Esac id  -> id
-        T_While id  -> id
-        T_Until id  -> id
-        T_For id  -> id
-        T_Select id  -> id
-        T_Lbrace id  -> id
-        T_Rbrace id  -> id
-        T_Lparen id  -> id
-        T_Rparen id  -> id
-        T_Bang id  -> id
-        T_In  id  -> id
-        T_NEWLINE id  -> id
-        T_EOF id  -> id
-        T_Less id  -> id
-        T_Greater id  -> id
-        T_SingleQuoted id _  -> id
-        T_Literal id _  -> id
-        T_NormalWord id _  -> id
-        T_DoubleQuoted id _  -> id
-        T_DollarExpansion id _  -> id
-        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
-        T_Assignment id _ _ _ _  -> id
-        T_Array id _  -> id
-        T_IndexedElement id _ _  -> id
-        T_Redirecting id _ _  -> id
-        T_SimpleCommand id _ _  -> id
-        T_Pipeline id _ _  -> id
-        T_Banged id _  -> id
-        T_AndIf id _ _ -> id
-        T_OrIf id _ _ -> id
-        T_Backgrounded id _  -> id
-        T_IfExpression id _ _  -> id
-        T_Subshell id _  -> id
-        T_BraceGroup id _  -> id
-        T_WhileExpression id _ _  -> id
-        T_UntilExpression id _ _  -> id
-        T_ForIn id _ _ _  -> id
-        T_SelectIn id _ _ _  -> id
-        T_CaseExpression id _ _ -> id
-        T_Function id _ _ _ _  -> id
-        T_Arithmetic id _  -> id
-        T_Script id _ _  -> id
-        T_Condition id _ _  -> id
-        T_Extglob id _ _ -> id
-        T_Backticked id _ -> id
-        TC_And id _ _ _ _  -> id
-        TC_Or id _ _ _ _  -> id
-        TC_Group id _ _  -> id
-        TC_Binary id _ _ _ _  -> id
-        TC_Unary id _ _ _  -> id
-        TC_Nullary id _ _  -> id
-        TA_Binary id _ _ _  -> id
-        TA_Assignment id _ _ _  -> id
-        TA_Unary id _ _  -> id
-        TA_Sequence id _  -> id
-        TA_Trinary id _ _ _  -> id
-        TA_Expansion id _  -> id
-        T_ProcSub id _ _ -> id
-        T_Glob id _ -> id
-        T_ForArithmetic id _ _ _ _ -> id
-        T_DollarSingleQuoted id _ -> id
-        T_DollarDoubleQuoted id _ -> id
-        T_DollarBracket id _ -> id
-        T_Annotation id _ _ -> id
-        T_Pipe id _ -> id
-        T_CoProc id _ _ -> id
-        T_CoProcBody id _ -> id
-        T_Include id _ -> id
-        T_SourceCommand id _ _ -> id
-        T_UnparsedIndex id _ _ -> id
-        TC_Empty id _ -> id
-        TA_Variable id _ _ -> id
-        T_BatsTest id _ _ -> id
+getId (OuterToken id _) = id
 
 blank :: Monad m => Token -> m ()
 blank = const $ return ()

src/ShellCheck/ASTLib.hs

@@ -25,6 +25,7 @@ import Control.Monad.Writer
 import Control.Monad
 import Data.Char
 import Data.Functor
+import Data.Functor.Identity
 import Data.List
 import Data.Maybe
 
@@ -46,6 +47,7 @@ willSplit x =
     T_BraceExpansion {} -> True
     T_Glob {} -> True
     T_Extglob {} -> True
+    T_DoubleQuoted _ l -> any willBecomeMultipleArgs l
     T_NormalWord _ l -> any willSplit l
     _ -> False
 
@@ -175,9 +177,13 @@ willConcatInAssignment token =
 getLiteralString :: Token -> Maybe String
 getLiteralString = getLiteralStringExt (const Nothing)
 
+-- Definitely get a literal string, with a given default for all non-literals
+getLiteralStringDef :: String -> Token -> String
+getLiteralStringDef x = runIdentity . getLiteralStringExt (const $ return x)
+
 -- Definitely get a literal string, skipping over all non-literals
 onlyLiteralString :: Token -> String
-onlyLiteralString = fromJust . getLiteralStringExt (const $ return "")
+onlyLiteralString = getLiteralStringDef ""
 
 -- Maybe get a literal string, but only if it's an unquoted argument.
 getUnquotedLiteral (T_NormalWord _ list) =
@@ -216,7 +222,7 @@ getGlobOrLiteralString = getLiteralStringExt f
 
 -- Maybe get the literal value of a token, using a custom function
 -- to map unrecognized Tokens into strings.
-getLiteralStringExt :: (Token -> Maybe String) -> Token -> Maybe String
+getLiteralStringExt :: Monad m => (Token -> m String) -> Token -> m String
 getLiteralStringExt more = g
   where
     allInList = fmap concat . mapM g
@@ -297,6 +303,11 @@ getCommand t =
 getCommandName :: Token -> Maybe String
 getCommandName = fst . getCommandNameAndToken
 
+-- Maybe get the name+arguments of a command.
+getCommandArgv t = do
+    (T_SimpleCommand _ _ args@(_:_)) <- getCommand t
+    return args
+
 -- Get the command name token from a command, i.e.
 -- the token representing 'ls' in 'ls -la 2> foo'.
 -- If it can't be determined, return the original token.
@@ -362,19 +373,23 @@ isFunctionLike t =
 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.
+-- the conditions and bodies of while loops or branches of if statements.
 getCommandSequences :: Token -> [[Token]]
 getCommandSequences t =
     case t of
         T_Script _ _ cmds -> [cmds]
         T_BraceGroup _ cmds -> [cmds]
         T_Subshell _ cmds -> [cmds]
-        T_WhileExpression _ _ cmds -> [cmds]
-        T_UntilExpression _ _ cmds -> [cmds]
+        T_WhileExpression _ cond cmds -> [cond, cmds]
+        T_UntilExpression _ cond cmds -> [cond, cmds]
         T_ForIn _ _ _ cmds -> [cmds]
         T_ForArithmetic _ _ _ _ cmds -> [cmds]
-        T_IfExpression _ thens elses -> map snd thens ++ [elses]
+        T_IfExpression _ thens elses -> (concatMap (\(a,b) -> [a,b]) thens) ++ [elses]
         T_Annotation _ _ t -> getCommandSequences t
+
+        T_DollarExpansion _ cmds -> [cmds]
+        T_DollarBraceCommandExpansion _ cmds -> [cmds]
+        T_Backticked _ cmds -> [cmds]
         _ -> []
 
 -- Get a list of names of associative arrays
@@ -382,7 +397,7 @@ getAssociativeArrays t =
     nub . execWriter $ doAnalysis f t
   where
     f :: Token -> Writer [String] ()
-    f t@T_SimpleCommand {} = fromMaybe (return ()) $ do
+    f t@T_SimpleCommand {} = sequence_ $ do
         name <- getCommandName t
         let assocNames = ["declare","local","typeset"]
         guard $ elem name assocNames

src/ShellCheck/Analyzer.hs

@@ -35,17 +35,18 @@ analyzeScript spec = newAnalysisResult {
     arComments =
         filterByAnnotation spec params . nub $
             runAnalytics spec
-            ++ runChecker params (checkers params)
+            ++ runChecker params (checkers spec params)
 }
   where
     params = makeParameters spec
 
-checkers params = mconcat $ map ($ params) [
-    ShellCheck.Checks.Commands.checker,
+checkers spec params = mconcat $ map ($ params) [
+    ShellCheck.Checks.Commands.checker spec,
     ShellCheck.Checks.Custom.checker,
     ShellCheck.Checks.ShellSupport.checker
     ]
 
 optionalChecks = mconcat $ [
-    ShellCheck.Analytics.optionalChecks
+    ShellCheck.Analytics.optionalChecks,
+    ShellCheck.Checks.Commands.optionalChecks
     ]

src/ShellCheck/AnalyzerLib.hs

@@ -239,19 +239,14 @@ prop_determineShell8 = determineShellTest' (Just Ksh) "#!/bin/sh" == Sh
 
 determineShellTest = determineShellTest' Nothing
 determineShellTest' fallbackShell = determineShell fallbackShell . fromJust . prRoot . pScript
-determineShell fallbackShell t = fromMaybe Bash $ do
-    shellString <- foldl mplus Nothing $ getCandidates t
+determineShell fallbackShell t = fromMaybe Bash $
     shellForExecutable shellString `mplus` fallbackShell
   where
-    forAnnotation t =
-        case t of
-            (ShellOverride s) -> return s
-            _                 -> fail ""
-    getCandidates :: Token -> [Maybe String]
-    getCandidates t@T_Script {} = [Just $ fromShebang t]
-    getCandidates (T_Annotation _ annotations s) =
-        map forAnnotation annotations ++
-           [Just $ fromShebang s]
+    shellString = getCandidate t
+    getCandidate :: Token -> String
+    getCandidate t@T_Script {} = fromShebang t
+    getCandidate (T_Annotation _ annotations s) =
+        headOrDefault (fromShebang s) [s | ShellOverride s <- annotations]
     fromShebang (T_Script _ (T_Literal _ s) _) = executableFromShebang s
 
 -- Given a string like "/bin/bash" or "/usr/bin/env dash",
@@ -259,7 +254,7 @@ determineShell fallbackShell t = fromMaybe Bash $ do
 executableFromShebang :: String -> String
 executableFromShebang = shellFor
   where
-    shellFor s | "/env " `isInfixOf` s = head (drop 1 (words s)++[""])
+    shellFor s | "/env " `isInfixOf` s = headOrDefault "" (drop 1 $ words s)
     shellFor s | ' ' `elem` s = shellFor $ takeWhile (/= ' ') s
     shellFor s = reverse . takeWhile (/= '/') . reverse $ s
 
@@ -299,7 +294,7 @@ isQuoteFree = isQuoteFreeNode False
 
 isQuoteFreeNode strict tree t =
     (isQuoteFreeElement t == Just True) ||
-        head (mapMaybe isQuoteFreeContext (drop 1 $ getPath tree t) ++ [False])
+        headOrDefault False (mapMaybe isQuoteFreeContext (drop 1 $ getPath tree t))
   where
     -- Is this node self-quoting in itself?
     isQuoteFreeElement t =
@@ -454,7 +449,7 @@ leadType params t =
         T_BatsTest {} -> SubshellScope "@bats test"
         T_CoProcBody _ _  -> SubshellScope "coproc"
         T_Redirecting {}  ->
-            if fromMaybe False causesSubshell
+            if causesSubshell == Just True
             then SubshellScope "pipeline"
             else NoneScope
         _ -> NoneScope
@@ -513,7 +508,7 @@ getModifiedVariables t =
         T_DollarBraced _ _ l -> maybeToList $ do
             let string = bracedString t
             let modifier = getBracedModifier string
-            guard $ ":=" `isPrefixOf` modifier
+            guard $ any (`isPrefixOf` modifier) ["=", ":="]
             return (t, t, getBracedReference string, DataString $ SourceFrom [l])
 
         t@(T_FdRedirect _ ('{':var) op) -> -- {foo}>&2 modifies foo
@@ -548,8 +543,9 @@ getReferencedVariableCommand base@(T_SimpleCommand _ _ (T_NormalWord _ (T_Litera
             else []
         "trap" ->
             case rest of
-                head:_ -> map (\x -> (head, head, x)) $ getVariablesFromLiteralToken head
+                head:_ -> map (\x -> (base, head, x)) $ getVariablesFromLiteralToken head
                 _ -> []
+        "alias" -> [(base, token, name) | token <- rest, name <- getVariablesFromLiteralToken token]
         _ -> []
   where
     getReference t@(T_Assignment _ _ name _ value) = [(t, t, name)]
@@ -567,9 +563,11 @@ getReferencedVariableCommand _ = []
 --   VariableName :: String,   -- The variable name, i.e. foo
 --   VariableValue :: DataType -- A description of the value being assigned, i.e. "Literal string with value foo"
 -- )
-getModifiedVariableCommand base@(T_SimpleCommand _ _ (T_NormalWord _ (T_Literal _ x:_):rest)) =
+getModifiedVariableCommand base@(T_SimpleCommand id cmdPrefix (T_NormalWord _ (T_Literal _ x:_):rest)) =
    filter (\(_,_,s,_) -> not ("-" `isPrefixOf` s)) $
     case x of
+        "builtin" ->
+            getModifiedVariableCommand $ T_SimpleCommand id cmdPrefix rest
         "read" ->
             let params = map getLiteral rest
                 readArrayVars = getReadArrayVariables rest
@@ -610,8 +608,7 @@ getModifiedVariableCommand base@(T_SimpleCommand _ _ (T_NormalWord _ (T_Literal
         _ -> []
   where
     flags = map snd $ getAllFlags base
-    stripEquals s = let rest = dropWhile (/= '=') s in
-        if rest == "" then "" else tail rest
+    stripEquals s = drop 1 $ dropWhile (/= '=') s
     stripEqualsFrom (T_NormalWord id1 (T_Literal id2 s:rs)) =
         T_NormalWord id1 (T_Literal id2 (stripEquals s):rs)
     stripEqualsFrom (T_NormalWord id1 [T_DoubleQuoted id2 [T_Literal id3 s]]) =
@@ -642,7 +639,7 @@ getModifiedVariableCommand base@(T_SimpleCommand _ _ (T_NormalWord _ (T_Literal
     getModifierParam _ _ = []
 
     letParamToLiteral token =
-          if var == ""
+          if null var
             then []
             else [(base, token, var, DataString $ SourceFrom [stripEqualsFrom token])]
         where var = takeWhile isVariableChar $ dropWhile (`elem` "+-") $ concat $ oversimplify token
@@ -761,9 +758,8 @@ getReferencedVariables parents t =
         _          -> Nothing
 
     getIfReference context token = maybeToList $ do
-            str <- getLiteralStringExt literalizer token
-            guard . not $ null str
-            when (isDigit $ head str) $ fail "is a number"
+            str@(h:_) <- getLiteralStringExt literalizer token
+            when (isDigit h) $ fail "is a number"
             return (context, token, getBracedReference str)
 
     isDereferencing = (`elem` ["-eq", "-ne", "-lt", "-le", "-gt", "-ge"])
@@ -783,8 +779,8 @@ isCommand token str = isCommandMatch token (\cmd -> cmd  == str || ('/' : str) `
 -- Compare a command to a literal. Like above, but checks full path.
 isUnqualifiedCommand token str = isCommandMatch token (== str)
 
-isCommandMatch token matcher = fromMaybe False $
-    fmap matcher (getCommandName token)
+isCommandMatch token matcher = maybe False
+    matcher (getCommandName token)
 
 -- Does this regex look like it was intended as a glob?
 -- True:  *foo*
@@ -805,7 +801,7 @@ isVariableName (x:r) = isVariableStartChar x && all isVariableChar r
 isVariableName _     = False
 
 getVariablesFromLiteralToken token =
-    getVariablesFromLiteral (fromJust $ getLiteralStringExt (const $ return " ") token)
+    getVariablesFromLiteral (getLiteralStringDef " " token)
 
 -- Try to get referenced variables from a literal string like "$foo"
 -- Ignores tons of cases like arithmetic evaluation and array indices.
@@ -855,7 +851,7 @@ getBracedReference s = fromMaybe s $
 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
+getBracedModifier s = headOrDefault "" $ do
     let var = getBracedReference s
     a <- dropModifier s
     dropPrefix var a
@@ -869,15 +865,6 @@ getBracedModifier s = fromMaybe "" . listToMaybe $ do
 
 -- 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"
-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
@@ -932,12 +919,11 @@ isQuotedAlternativeReference t =
 --     Just [("r", -re), ("e", -re), ("d", :), ("u", 3), ("", bar)]
 -- where flags with arguments map to arguments, while others map to themselves.
 -- Any unrecognized flag will result in Nothing.
-getGnuOpts = getOpts getAllFlags
-getBsdOpts = getOpts getLeadingFlags
-getOpts :: (Token -> [(Token, String)]) -> String -> Token -> Maybe [(String, Token)]
-getOpts flagTokenizer string cmd = process flags
+getGnuOpts str t = getOpts str $ getAllFlags t
+getBsdOpts str t = getOpts str $ getLeadingFlags t
+getOpts :: String -> [(Token, String)] -> Maybe [(String, Token)]
+getOpts string flags = process flags
   where
-    flags = flagTokenizer cmd
     flagList (c:':':rest) = ([c], True) : flagList rest
     flagList (c:rest)     = ([c], False) : flagList rest
     flagList []           = []
@@ -952,7 +938,7 @@ getOpts flagTokenizer string cmd = process flags
         takesArg <- Map.lookup flag1 flagMap
         if takesArg
             then do
-                guard $ flag2 == ""
+                guard $ null flag2
                 more <- process rest
                 return $ (flag1, token2) : more
             else do

src/ShellCheck/Checker.hs

@@ -48,7 +48,7 @@ tokenToPosition startMap t = fromMaybe fail $ do
   where
     fail = error "Internal shellcheck error: id doesn't exist. Please report!"
 
-shellFromFilename filename = foldl mplus Nothing candidates
+shellFromFilename filename = listToMaybe candidates
   where
     shellExtensions = [(".ksh", Ksh)
                       ,(".bash", Bash)
@@ -57,7 +57,7 @@ shellFromFilename filename = foldl mplus Nothing candidates
                       -- The `.sh` is too generic to determine the shell:
                       -- We fallback to Bash in this case and emit SC2148 if there is no shebang
     candidates =
-        map (\(ext,sh) -> if ext `isSuffixOf` filename then Just sh else Nothing) shellExtensions
+        [sh | (ext,sh) <- shellExtensions, ext `isSuffixOf` filename]
 
 checkScript :: Monad m => SystemInterface m -> CheckSpec -> m CheckResult
 checkScript sys spec = do
@@ -88,9 +88,9 @@ checkScript sys spec = do
                     asOptionalChecks = csOptionalChecks spec
                 } where as = newAnalysisSpec root
         let analysisMessages =
-                fromMaybe [] $
+                maybe []
                     (arComments . analyzeScript . analysisSpec)
-                        <$> prRoot result
+                        $ prRoot result
         let translator = tokenToPosition tokenPositions
         return . nub . sortMessages . filter shouldInclude $
             (parseMessages ++ map translator analysisMessages)
@@ -104,7 +104,7 @@ checkScript sys spec = do
             code     = cCode (pcComment pc)
             severity = cSeverity (pcComment pc)
 
-    sortMessages = sortBy (comparing order)
+    sortMessages = sortOn order
     order pc =
         let pos = pcStartPos pc
             comment = pcComment pc in
@@ -198,11 +198,11 @@ prop_optionDisablesBadShebang =
                 }
 
 prop_annotationDisablesBadShebang =
-    [] == check "#!/usr/bin/python\n# shellcheck shell=sh\ntrue\n"
+    null $ check "#!/usr/bin/python\n# shellcheck shell=sh\ntrue\n"
 
 
 prop_canParseDevNull =
-    [] == check "source /dev/null"
+    null $ check "source /dev/null"
 
 prop_failsWhenNotSourcing =
     [1091, 2154] == check "source lol; echo \"$bar\""
@@ -218,7 +218,7 @@ prop_worksWhenDotting =
 
 -- FIXME: This should really be giving [1093], "recursively sourced"
 prop_noInfiniteSourcing =
-    [] == checkWithIncludes  [("lib", "source lib")] "source lib"
+    null $ checkWithIncludes  [("lib", "source lib")] "source lib"
 
 prop_canSourceBadSyntax =
     [1094, 2086] == checkWithIncludes [("lib", "for f; do")] "source lib; echo $1"
@@ -239,10 +239,10 @@ prop_recursiveParsing =
     [1037] == checkRecursive [("lib", "echo \"$10\"")] "source lib"
 
 prop_nonRecursiveAnalysis =
-    [] == checkWithIncludes [("lib", "echo $1")] "source lib"
+    null $ checkWithIncludes [("lib", "echo $1")] "source lib"
 
 prop_nonRecursiveParsing =
-    [] == checkWithIncludes [("lib", "echo \"$10\"")] "source lib"
+    null $ checkWithIncludes [("lib", "echo \"$10\"")] "source lib"
 
 prop_sourceDirectiveDoesntFollowFile =
     null $ checkWithIncludes
@@ -288,6 +288,13 @@ prop_deducesTypeFromExtension2 = result == [2079]
         csScript = "(( 3.14 ))"
     }
 
+prop_canDisableShebangWarning = null $ result
+  where
+    result = checkWithSpec [] emptyCheckSpec {
+        csFilename = "file.sh",
+        csScript = "#shellcheck disable=SC2148\nfoo"
+    }
+
 prop_shExtensionDoesntMatter = result == [2148]
   where
     result = checkWithSpec [] emptyCheckSpec {
@@ -328,7 +335,7 @@ prop_optionIncludes4 =
     [2154] == checkOptionIncludes (Just [2154]) "#!/bin/sh\n var='a b'\n echo $var\n echo $bar"
 
 
-prop_readsRcFile = result == []
+prop_readsRcFile = null result
   where
     result = checkWithRc "disable=2086" emptyCheckSpec {
         csScript = "#!/bin/sh\necho $1",

src/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 , ShellCheck.Checks.Commands.runTests) where
+module ShellCheck.Checks.Commands (checker, optionalChecks, ShellCheck.Checks.Commands.runTests) where
 
 import ShellCheck.AST
 import ShellCheck.ASTLib
@@ -34,6 +34,7 @@ import ShellCheck.Regex
 import Control.Monad
 import Control.Monad.RWS
 import Data.Char
+import Data.Functor.Identity
 import Data.List
 import Data.Maybe
 import qualified Data.Map.Strict as Map
@@ -90,13 +91,30 @@ commandChecks = [
     ,checkMvArguments, checkCpArguments, checkLnArguments
     ,checkFindRedirections
     ,checkReadExpansions
-    ,checkWhich
     ,checkSudoRedirect
     ,checkSudoArgs
     ,checkSourceArgs
     ,checkChmodDashr
     ]
 
+optionalChecks = map fst optionalCommandChecks
+optionalCommandChecks :: [(CheckDescription, CommandCheck)]
+optionalCommandChecks = [
+    (newCheckDescription {
+        cdName = "deprecate-which",
+        cdDescription = "Suggest 'command -v' instead of 'which'",
+        cdPositive = "which javac",
+        cdNegative = "command -v javac"
+    }, checkWhich)
+    ]
+optionalCheckMap = Map.fromList $ map (\(desc, check) -> (cdName desc, check)) optionalCommandChecks
+
+prop_verifyOptionalExamples = all check optionalCommandChecks
+  where
+    check (desc, check) =
+      verify check (cdPositive desc)
+      && verifyNot check (cdNegative desc)
+
 buildCommandMap :: [CommandCheck] -> Map.Map CommandName (Token -> Analysis)
 buildCommandMap = foldl' addCheck Map.empty
   where
@@ -105,12 +123,16 @@ buildCommandMap = foldl' addCheck Map.empty
 
 
 checkCommand :: Map.Map CommandName (Token -> Analysis) -> Token -> Analysis
-checkCommand map t@(T_SimpleCommand id _ (cmd:rest)) = fromMaybe (return ()) $ do
+checkCommand map t@(T_SimpleCommand id cmdPrefix (cmd:rest)) = sequence_ $ do
     name <- getLiteralString cmd
     return $
         if '/' `elem` name
         then
             Map.findWithDefault nullCheck (Basename $ basename name) map t
+        else if name == "builtin" && not (null rest) then
+            let t' = T_SimpleCommand id cmdPrefix rest
+                selectedBuiltin = fromMaybe "" $ getLiteralString . head $ rest
+            in Map.findWithDefault nullCheck (Exactly selectedBuiltin) map t'
         else do
             Map.findWithDefault nullCheck (Exactly name) map t
             Map.findWithDefault nullCheck (Basename name) map t
@@ -128,8 +150,14 @@ getChecker list = Checker {
     map = buildCommandMap list
 
 
-checker :: Parameters -> Checker
-checker params = getChecker commandChecks
+checker :: AnalysisSpec -> Parameters -> Checker
+checker spec params = getChecker $ commandChecks ++ optionals
+  where
+    keys = asOptionalChecks spec
+    optionals =
+        if "all" `elem` keys
+        then map snd optionalCommandChecks
+        else mapMaybe (\x -> Map.lookup x optionalCheckMap) keys
 
 prop_checkTr1 = verify checkTr "tr [a-f] [A-F]"
 prop_checkTr2 = verify checkTr "tr 'a-z' 'A-Z'"
@@ -169,15 +197,14 @@ prop_checkFindNameGlob1 = verify checkFindNameGlob "find / -name *.php"
 prop_checkFindNameGlob2 = verify checkFindNameGlob "find / -type f -ipath *(foo)"
 prop_checkFindNameGlob3 = verifyNot checkFindNameGlob "find * -name '*.php'"
 checkFindNameGlob = CommandCheck (Basename "find") (f . arguments)  where
-    acceptsGlob (Just s) = s `elem` [ "-ilname", "-iname", "-ipath", "-iregex", "-iwholename", "-lname", "-name", "-path", "-regex", "-wholename" ]
-    acceptsGlob _ = False
+    acceptsGlob s = s `elem` [ "-ilname", "-iname", "-ipath", "-iregex", "-iwholename", "-lname", "-name", "-path", "-regex", "-wholename" ]
     f [] = return ()
-    f [x] = return ()
-    f (a:b:r) = do
-        when (acceptsGlob (getLiteralString a) && isGlob b) $ do
-            let (Just s) = getLiteralString a
+    f (x:xs) = g x xs
+    g _ [] = return ()
+    g a (b:r) = do
+        forM_ (getLiteralString a) $ \s -> when (acceptsGlob s && isGlob b) $
             warn (getId b) 2061 $ "Quote the parameter to " ++ s ++ " so the shell won't interpret it."
-        f (b:r)
+        g b r
 
 
 prop_checkNeedlessExpr = verify checkNeedlessExpr "foo=$(expr 3 + 2)"
@@ -221,13 +248,12 @@ prop_checkGrepRe23= verifyNot checkGrepRe "grep '.*' file"
 checkGrepRe = CommandCheck (Basename "grep") check where
     check cmd = f cmd (arguments cmd)
     -- --regex=*(extglob) doesn't work. Fixme?
-    skippable (Just s) = not ("--regex=" `isPrefixOf` s) && "-" `isPrefixOf` s
-    skippable _ = False
+    skippable s = not ("--regex=" `isPrefixOf` s) && "-" `isPrefixOf` s
     f _ [] = return ()
     f cmd (x:r) =
-        let str = getLiteralStringExt (const $ return "_") x
+        let str = getLiteralStringDef "_" x
         in
-            if str `elem` [Just "--", Just "-e", Just "--regex"]
+            if str `elem` ["--", "-e", "--regex"]
             then checkRE cmd r -- Regex is *after* this
             else
                 if skippable str
@@ -243,7 +269,7 @@ checkGrepRe = CommandCheck (Basename "grep") check where
             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
+              else sequence_ $ do
                 char <- getSuspiciousRegexWildcard string
                 return $ info (getId re) 2022 $
                     "Note that unlike globs, " ++ [char] ++ "* here matches '" ++ [char, char, char] ++ "' but not '" ++ wordStartingWith char ++ "'."
@@ -252,10 +278,10 @@ checkGrepRe = CommandCheck (Basename "grep") check where
         grepGlobFlags = ["fixed-strings", "F", "include", "exclude", "exclude-dir", "o", "only-matching"]
 
     wordStartingWith c =
-        head . filter ([c] `isPrefixOf`) $ candidates
+        headOrDefault (c:"test") . filter ([c] `isPrefixOf`) $ candidates
       where
         candidates =
-            sampleWords ++ map (\(x:r) -> toUpper x : r) sampleWords ++ [c:"test"]
+            sampleWords ++ map (\(x:r) -> toUpper x : r) sampleWords
 
     getSuspiciousRegexWildcard str =
         if not $ str `matches` contra
@@ -318,10 +344,10 @@ returnOrExit multi invalid = (f . arguments)
             invalid (getId value)
     f _ = return ()
 
-    isInvalid s = s == "" || any (not . isDigit) s || length s > 5
+    isInvalid s = null s || any (not . isDigit) s || length s > 5
         || let value = (read s :: Integer) in value > 255
 
-    literal token = fromJust $ getLiteralStringExt lit token
+    literal token = runIdentity $ getLiteralStringExt lit token
     lit (T_DollarBraced {}) = return "0"
     lit (T_DollarArithmetic {}) = return "0"
     lit (T_DollarExpansion {}) = return "0"
@@ -338,7 +364,7 @@ checkFindExecWithSingleArgument = CommandCheck (Basename "find") (f . arguments)
     check (exec:arg:term:_) = do
         execS <- getLiteralString exec
         termS <- getLiteralString term
-        cmdS <- getLiteralStringExt (const $ return " ") arg
+        let cmdS = getLiteralStringDef " " arg
 
         guard $ execS `elem` ["-exec", "-execdir"] && termS `elem` [";", "+"]
         guard $ cmdS `matches` commandRegex
@@ -434,7 +460,7 @@ 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
+    check t = sequence_ $ do
         let flags = getAllFlags t
         dashP <- find ((\f -> f == "p" || f == "parents") . snd) flags
         dashM <- find ((\f -> f == "m" || f == "mode") . snd) flags
@@ -460,7 +486,7 @@ checkNonportableSignals = CommandCheck (Exactly "trap") (f . arguments)
         first:rest -> unless (isFlag first) $ mapM_ check rest
         _ -> return ()
 
-    check param = potentially $ do
+    check param = sequence_ $ do
         str <- getLiteralString param
         let id = getId param
         return $ sequence_ $ mapMaybe (\f -> f id str) [
@@ -548,7 +574,7 @@ checkPrintfVar = CommandCheck (Exactly "printf") (f . arguments) where
     f _ = return ()
 
     check format more = do
-        fromMaybe (return ()) $ do
+        sequence_ $ do
             string <- getLiteralString format
             let formats = getPrintfFormats string
             let formatCount = length formats
@@ -573,7 +599,7 @@ checkPrintfVar = CommandCheck (Exactly "printf") (f . arguments) where
 
         unless ('%' `elem` concat (oversimplify format) || isLiteral format) $
           info (getId format) 2059
-              "Don't use variables in the printf format string. Use printf \"..%s..\" \"$foo\"."
+              "Don't use variables in the printf format string. Use printf '..%s..' \"$foo\"."
       where
         onlyTrailingTs format argCount =
             all (== 'T') $ drop argCount format
@@ -660,7 +686,7 @@ prop_checkExportedExpansions3 = verifyNot checkExportedExpansions "export foo"
 prop_checkExportedExpansions4 = verifyNot checkExportedExpansions "export ${foo?}"
 checkExportedExpansions = CommandCheck (Exactly "export") (mapM_ check . arguments)
   where
-    check t = potentially $ do
+    check t = sequence_ $ do
         var <- getSingleUnmodifiedVariable t
         let name = bracedString var
         return . warn (getId t) 2163 $
@@ -676,13 +702,13 @@ prop_checkReadExpansions7 = verifyNot checkReadExpansions "read $1"
 prop_checkReadExpansions8 = verifyNot checkReadExpansions "read ${var?}"
 checkReadExpansions = CommandCheck (Exactly "read") check
   where
-    options = getGnuOpts "sreu:n:N:i:p:a:"
+    options = getGnuOpts flagsForRead
     getVars cmd = fromMaybe [] $ do
         opts <- options cmd
-        return . map snd $ filter (\(x,_) -> x == "" || x == "a") opts
+        return [y | (x,y) <- opts, null x || x == "a"]
 
     check cmd = mapM_ warning $ getVars cmd
-    warning t = potentially $ do
+    warning t = sequence_ $ do
         var <- getSingleUnmodifiedVariable t
         let name = bracedString var
         guard $ isVariableName name   -- e.g. not $1
@@ -708,7 +734,7 @@ checkAliasesUsesArgs = CommandCheck (Exactly "alias") (f . arguments)
     re = mkRegex "\\$\\{?[0-9*@]"
     f = mapM_ checkArg
     checkArg arg =
-        let string = fromJust $ getLiteralStringExt (const $ return "_") arg in
+        let string = getLiteralStringDef "_" arg in
             when ('=' `elem` string && string `matches` re) $
                 err (getId arg) 2142
                     "Aliases can't use positional parameters. Use a function."
@@ -721,7 +747,7 @@ checkAliasesExpandEarly = CommandCheck (Exactly "alias") (f . arguments)
   where
     f = mapM_ checkArg
     checkArg arg | '=' `elem` concat (oversimplify arg) =
-        forM_ (take 1 $ filter (not . isLiteral) $ getWordParts arg) $
+        forM_ (find (not . isLiteral) $ getWordParts arg) $
             \x -> warn (getId x) 2139 "This expands when defined, not when used. Consider escaping."
     checkArg _ = return ()
 
@@ -754,7 +780,7 @@ checkFindWithoutPath = CommandCheck (Basename "find") f
     -- path. We assume that all the pre-path flags are single characters from a
     -- list of GNU and macOS flags.
     hasPath (first:rest) =
-        let flag = fromJust $ getLiteralStringExt (const $ return "___") first in
+        let flag = getLiteralStringDef "___" first in
             not ("-" `isPrefixOf` flag) || isLeadingFlag flag && hasPath rest
     hasPath [] = False
     isLeadingFlag flag = length flag <= 2 || all (`elem` leadingFlagChars) flag
@@ -832,7 +858,7 @@ checkWhileGetoptsCase = CommandCheck (Exactly "getopts") f
     f :: Token -> Analysis
     f t@(T_SimpleCommand _ _ (cmd:arg1:_))  = do
         path <- getPathM t
-        potentially $ do
+        sequence_ $ do
             options <- getLiteralString arg1
             (T_WhileExpression _ _ body) <- findFirst whileLoop path
             caseCmd <- mapMaybe findCase body !!! 0
@@ -859,7 +885,7 @@ checkWhileGetoptsCase = CommandCheck (Exactly "getopts") f
     warnUnhandled optId caseId str =
         warn caseId 2213 $ "getopts specified -" ++ str ++ ", but it's not handled by this 'case'."
 
-    warnRedundant (key, expr) = potentially $ do
+    warnRedundant (key, expr) = sequence_ $ do
         str <- key
         guard $ str `notElem` ["*", ":", "?"]
         return $ warn (getId expr) 2214 "This case is not specified by getopts."
@@ -918,7 +944,7 @@ checkCatastrophicRm = CommandCheck (Basename "rm") $ \t ->
             Nothing ->
                 checkWord' token
 
-    checkWord' token = fromMaybe (return ()) $ do
+    checkWord' token = sequence_ $ do
         filename <- getPotentialPath token
         let path = fixPath filename
         return . when (path `elem` importantPaths) $
@@ -968,10 +994,9 @@ missingDestination handler token = do
         _ -> return ()
   where
     args = getAllFlags token
-    params = map fst $ filter (\(_,x) -> x == "") args
+    params = [x | (x,"") <- args]
     hasTarget =
-        any (\x -> x /= "" && x `isPrefixOf` "target-directory") $
-            map snd args
+        any (\(_,x) -> x /= "" && x `isPrefixOf` "target-directory") args
 
 prop_checkMvArguments1 = verify    checkMvArguments "mv 'foo bar'"
 prop_checkMvArguments2 = verifyNot checkMvArguments "mv foo bar"
@@ -1031,7 +1056,7 @@ checkSudoRedirect = CommandCheck (Basename "sudo") f
             Just (T_Redirecting _ redirs _) ->
                 mapM_ warnAbout redirs
     warnAbout (T_FdRedirect _ s (T_IoFile id op file))
-        | (s == "" || s == "&") && not (special file) =
+        | (null s || s == "&") && not (special file) =
         case op of
             T_Less _ ->
               info (getId op) 2024
@@ -1055,9 +1080,9 @@ prop_checkSudoArgs6 = verifyNot checkSudoArgs "sudo -n -u export ls"
 prop_checkSudoArgs7 = verifyNot checkSudoArgs "sudo docker export foo"
 checkSudoArgs = CommandCheck (Basename "sudo") f
   where
-    f t = potentially $ do
+    f t = sequence_ $ do
         opts <- parseOpts t
-        let nonFlags = map snd $ filter (\(flag, _) -> flag == "") opts
+        let nonFlags = [x | ("",x) <- opts]
         commandArg <- nonFlags !!! 0
         command <- getLiteralString commandArg
         guard $ command `elem` builtins
@@ -1083,7 +1108,7 @@ prop_checkChmodDashr3 = verifyNot checkChmodDashr "chmod a-r dir"
 checkChmodDashr = CommandCheck (Basename "chmod") f
   where
     f t = mapM_ check $ arguments t
-    check t = potentially $ do
+    check t = sequence_ $ do
         flag <- getLiteralString t
         guard $ flag == "-r"
         return $ warn (getId t) 2253 "Use -R to recurse, or explicitly a-r to remove read permissions."

src/ShellCheck/Checks/ShellSupport.hs

@@ -30,6 +30,7 @@ import ShellCheck.Regex
 import Control.Monad
 import Control.Monad.RWS
 import Data.Char
+import Data.Functor.Identity
 import Data.List
 import Data.Maybe
 import qualified Data.Map as Map
@@ -73,7 +74,7 @@ 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
+    f t@(TA_Expansion id _) = sequence_ $ do
         str <- getLiteralString t
         first <- str !!! 0
         guard $ isDigit first && '.' `elem` str
@@ -205,7 +206,7 @@ checkBashisms = ForShell [Sh, Dash] $ \t -> do
         | op `elem` [ "<", ">", "\\<", "\\>", "<=", ">=", "\\<=", "\\>="] =
             unless isDash $ warnMsg id $ "lexicographical " ++ op ++ " is"
     bashism (TC_Binary id SingleBracket op _ _)
-        | op `elem` [ "-nt", "-ef" ] =
+        | op `elem` [ "-ot", "-nt", "-ef" ] =
             unless isDash $ warnMsg id $ op ++ " is"
     bashism (TC_Binary id SingleBracket "==" _ _) =
             warnMsg id "== in place of = is"
@@ -337,17 +338,17 @@ checkBashisms = ForShell [Sh, Dash] $ \t -> do
         in do
             when (name `elem` unsupportedCommands) $
                 warnMsg id $ "'" ++ name ++ "' is"
-            potentially $ do
+            sequence_ $ do
                 allowed' <- Map.lookup name allowedFlags
                 allowed <- allowed'
-                (word, flag) <- listToMaybe $
-                    filter (\x -> (not . null . snd $ x) && snd x `notElem` allowed) flags
+                (word, flag) <- find
+                    (\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
+                    check token = sequence_ $ do
                         str <- getLiteralString token
                         let upper = map toUpper str
                         return $ do
@@ -362,7 +363,7 @@ checkBashisms = ForShell [Sh, Dash] $ \t -> do
                 in
                     mapM_ check (drop 1 rest)
 
-            when (name == "printf") $ potentially $ do
+            when (name == "printf") $ sequence_ $ do
                 format <- rest !!! 0  -- flags are covered by allowedFlags
                 let literal = onlyLiteralString format
                 guard $ "%q" `isInfixOf` literal
@@ -456,11 +457,10 @@ checkEchoSed = ForShell [Bash, Ksh] f
 
     -- 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
+    isSimpleSed s = isJust $ do
+        [h:_,rest] <- matchRegex sedRe s
+        let delimiters = filter (== h) rest
         guard $ length delimiters == 2
-        return True
     checkIn id s =
         when (isSimpleSed s) $
             style id 2001 "See if you can use ${variable//search/replace} instead."
@@ -487,11 +487,11 @@ checkBraceExpansionVars = ForShell [Bash] f
             T_DollarBraced {} -> return "$"
             T_DollarExpansion {} -> return "$"
             T_DollarArithmetic {} -> return "$"
-            otherwise -> return "-"
-    toString t = fromJust $ getLiteralStringExt literalExt t
+            _ -> return "-"
+    toString t = runIdentity $ getLiteralStringExt literalExt t
     isEvaled t = do
         cmd <- getClosestCommandM t
-        return $ isJust cmd && fromJust cmd `isUnqualifiedCommand` "eval"
+        return $ maybe False (`isUnqualifiedCommand` "eval") cmd
 
 
 prop_checkMultiDimensionalArrays1 = verify checkMultiDimensionalArrays "foo[a][b]=3"

src/ShellCheck/Data.hs

@@ -114,6 +114,10 @@ binaryTestOps = [
     "-gt", "-ge", "=~", ">", "<", "=", "\\<", "\\>", "\\<=", "\\>="
   ]
 
+arithmeticBinaryTestOps = [
+    "-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",
@@ -131,4 +135,6 @@ shellForExecutable name =
         "ksh"   -> return Ksh
         "ksh88" -> return Ksh
         "ksh93" -> return Ksh
-        otherwise -> Nothing
+        _ -> Nothing
+
+flagsForRead = "sreu:n:N:i:p:a:t:"

src/ShellCheck/Fixer.hs

@@ -200,7 +200,7 @@ doReplace start end o r =
     let si = fromIntegral (start-1)
         ei = fromIntegral (end-1)
         (x, xs) = splitAt si o
-        (y, z) = splitAt (ei - si) xs
+        z = drop (ei - si) xs
     in
     x ++ r ++ z
 
@@ -295,7 +295,7 @@ prop_pstreeSumsCorrectly kvs targets =
     -- Trivial O(n * m) implementation
     dumbPrefixSums :: [(Int, Int)] -> [Int] -> [Int]
     dumbPrefixSums kvs targets =
-        let prefixSum target = sum . map snd . filter (\(k,v) -> k <= target) $ kvs
+        let prefixSum target = sum [v | (k,v) <- kvs, k <= target]
         in map prefixSum targets
     -- PSTree O(n * log m) implementation
     smartPrefixSums :: [(Int, Int)] -> [Int] -> [Int]

src/ShellCheck/Formatter/Diff.hs

@@ -43,14 +43,15 @@ ltt x = trace (show x) x
 
 format :: FormatterOptions -> IO Formatter
 format options = do
-    didOutput <- newIORef False
+    foundIssues <- newIORef False
+    reportedIssues <- newIORef False
     shouldColor <- shouldOutputColor (foColorOption options)
     let color = if shouldColor then colorize else nocolor
     return Formatter {
         header = return (),
-        footer = checkFooter didOutput color,
+        footer = checkFooter foundIssues reportedIssues color,
         onFailure = reportFailure color,
-        onResult  = reportResult didOutput color
+        onResult  = reportResult foundIssues reportedIssues color
     }
 
 
@@ -69,9 +70,10 @@ printErr :: ColorFunc -> String -> IO ()
 printErr color = hPutStrLn stderr . color bold . color red
 reportFailure color file msg = printErr color $ file ++ ": " ++ msg
 
-checkFooter didOutput color = do
-    output <- readIORef didOutput
-    unless output $
+checkFooter foundIssues reportedIssues color = do
+    found <- readIORef foundIssues
+    output <- readIORef reportedIssues
+    when (found && not output) $
             printErr color "Issues were detected, but none were auto-fixable. Use another format to see them."
 
 type ColorFunc = (Int -> String -> String)
@@ -79,9 +81,10 @@ data LFStatus = LinefeedMissing | LinefeedOk
 data DiffDoc a = DiffDoc String LFStatus [DiffRegion a]
 data DiffRegion a = DiffRegion (Int, Int) (Int, Int) [Diff a]
 
-reportResult :: (IORef Bool) -> ColorFunc -> CheckResult -> SystemInterface IO -> IO ()
-reportResult didOutput color result sys = do
+reportResult :: (IORef Bool) -> (IORef Bool) -> ColorFunc -> CheckResult -> SystemInterface IO -> IO ()
+reportResult foundIssues reportedIssues color result sys = do
     let comments = crComments result
+    unless (null comments) $ writeIORef foundIssues True
     let suggestedFixes = mapMaybe pcFix comments
     let fixmap = buildFixMap suggestedFixes
     mapM_ output $ M.toList fixmap
@@ -91,7 +94,7 @@ reportResult didOutput color result sys = do
         case file of
             Right contents -> do
                 putStrLn $ formatDoc color $ makeDiff name contents fix
-                writeIORef didOutput True
+                writeIORef reportedIssues True
             Left msg -> reportFailure color name msg
 
 hasTrailingLinefeed str =

src/ShellCheck/Interface.hs

@@ -256,9 +256,6 @@ data Replacement = Replacement {
 data InsertionPoint = InsertBefore | InsertAfter
     deriving (Show, Eq, Generic, NFData)
 
-instance Ord Replacement where
-    compare r1 r2 = (repStartPos r1) `compare` (repStartPos r2)
-
 newReplacement = Replacement {
     repStartPos = newPosition,
     repEndPos = newPosition,
@@ -316,10 +313,10 @@ mockedSystemInterface files = SystemInterface {
     siGetConfig = const $ return Nothing
 }
   where
-    rf file =
-        case filter ((== file) . fst) files of
-            [] -> return $ Left "File not included in mock."
-            [(_, contents)] -> return $ Right contents
+    rf file = return $
+        case find ((== file) . fst) files of
+            Nothing -> Left "File not included in mock."
+            Just (_, contents) -> Right contents
     fs _ _ file = return file
 
 mockRcFile rcfile mock = mock {

src/ShellCheck/Parser.hs

@@ -34,7 +34,7 @@ import Control.Monad.Identity
 import Control.Monad.Trans
 import Data.Char
 import Data.Functor
-import Data.List (isPrefixOf, isInfixOf, isSuffixOf, partition, sortBy, intercalate, nub)
+import Data.List (isPrefixOf, isInfixOf, isSuffixOf, partition, sortBy, intercalate, nub, find)
 import Data.Maybe
 import Data.Monoid
 import Debug.Trace
@@ -186,12 +186,12 @@ getNextIdSpanningTokens startTok endTok = do
 
 -- Get an ID starting from the first token of the list, and ending after the last
 getNextIdSpanningTokenList list =
-    if null list
-    then do
+    case list of
+    [] -> do
         pos <- getPosition
         getNextIdBetween pos pos
-    else
-        getNextIdSpanningTokens (head list) (last list)
+    (h:_) ->
+        getNextIdSpanningTokens h (last list)
 
 -- Get the span covered by an id
 getSpanForId :: Monad m => Id -> SCParser m (SourcePos, SourcePos)
@@ -246,6 +246,10 @@ addParseNote n = do
             parseNotes = n : parseNotes state
         }
 
+ignoreProblemsOf p = do
+    systemState <- lift . lift $ Ms.get
+    p <* (lift . lift . Ms.put $ systemState)
+
 shouldIgnoreCode code = do
     context <- getCurrentContexts
     checkSourced <- Mr.asks checkSourced
@@ -321,16 +325,15 @@ parseProblem level code msg = do
     parseProblemAt pos level code msg
 
 setCurrentContexts c = Ms.modify (\state -> state { contextStack = c })
-getCurrentContexts = contextStack <$> Ms.get
+getCurrentContexts = Ms.gets contextStack
 
 popContext = do
     v <- getCurrentContexts
-    if not $ null v
-        then do
-            let (a:r) = v
+    case v of
+        (a:r) -> do
             setCurrentContexts r
             return $ Just a
-        else
+        [] ->
             return Nothing
 
 pushContext c = do
@@ -437,6 +440,7 @@ readConditionContents single =
     readCondContents `attempting` lookAhead (do
                                 pos <- getPosition
                                 s <- readVariableName
+                                spacing1
                                 when (s `elem` commonCommands) $
                                     parseProblemAt pos WarningC 1014 "Use 'if cmd; then ..' to check exit code, or 'if [[ $(cmd) == .. ]]' to check output.")
 
@@ -582,9 +586,9 @@ readConditionContents single =
             return $ TC_Nullary id typ x
           )
 
-    checkTrailingOp x = fromMaybe (return ()) $ do
+    checkTrailingOp x = sequence_ $ do
         (T_Literal id str) <- getTrailingUnquotedLiteral x
-        trailingOp <- listToMaybe (filter (`isSuffixOf` str) binaryTestOps)
+        trailingOp <- find (`isSuffixOf` str) binaryTestOps
         return $ parseProblemAtId id ErrorC 1108 $
             "You need a space before and after the " ++ trailingOp ++ " ."
 
@@ -910,6 +914,8 @@ prop_readCondition20 = isOk readCondition "[[ echo_rc -eq 0 ]]"
 prop_readCondition21 = isOk readCondition "[[ $1 =~ ^(a\\ b)$ ]]"
 prop_readCondition22 = isOk readCondition "[[ $1 =~ \\.a\\.(\\.b\\.)\\.c\\. ]]"
 prop_readCondition23 = isOk readCondition "[[ -v arr[$var] ]]"
+prop_readCondition24 = isWarning readCondition "[[ 1 == 2 ]]]"
+prop_readCondition25 = isOk readCondition "[[ lex.yy.c -ot program.l ]]"
 readCondition = called "test expression" $ do
     opos <- getPosition
     start <- startSpan
@@ -938,6 +944,11 @@ readCondition = called "test expression" $ do
     id <- endSpan start
     when (open == "[[" && close /= "]]") $ parseProblemAt cpos ErrorC 1033 "Did you mean ]] ?"
     when (open == "[" && close /= "]" ) $ parseProblemAt opos ErrorC 1034 "Did you mean [[ ?"
+    optional $ lookAhead $ do
+        pos <- getPosition
+        notFollowedBy2 readCmdWord <|>
+            parseProblemAt pos ErrorC 1136
+                ("Unexpected characters after terminating " ++ close ++ ". Missing semicolon/linefeed?")
     spacing
     many readCmdWord -- Read and throw away remainders to get then/do warnings. Fixme?
     return $ T_Condition id typ condition
@@ -1032,14 +1043,16 @@ prop_readNormalWord9 = isOk readSubshell "(foo\\ ;\nbar)"
 prop_readNormalWord10 = isWarning readNormalWord "\x201Chello\x201D"
 prop_readNormalWord11 = isWarning readNormalWord "\x2018hello\x2019"
 prop_readNormalWord12 = isWarning readNormalWord "hello\x2018"
-readNormalWord = readNormalishWord ""
+readNormalWord = readNormalishWord "" ["do", "done", "then", "fi", "esac"]
 
-readNormalishWord end = do
+readPatternWord = readNormalishWord "" ["esac"]
+
+readNormalishWord end terms = do
     start <- startSpan
     pos <- getPosition
     x <- many1 (readNormalWordPart end)
     id <- endSpan start
-    checkPossibleTermination pos x
+    checkPossibleTermination pos x terms
     return $ T_NormalWord id x
 
 readIndexSpan = do
@@ -1059,10 +1072,10 @@ readIndexSpan = do
         id <- endSpan start
         return $ T_Literal id str
 
-checkPossibleTermination pos [T_Literal _ x] =
-    when (x `elem` ["do", "done", "then", "fi", "esac"]) $
+checkPossibleTermination pos [T_Literal _ x] terminators =
+    when (x `elem` terminators) $
         parseProblemAt pos WarningC 1010 $ "Use semicolon or linefeed before '" ++ x ++ "' (or quote to make it literal)."
-checkPossibleTermination _ _ = return ()
+checkPossibleTermination _ _ _ = return ()
 
 readNormalWordPart end = do
     notFollowedBy2 $ oneOf end
@@ -1541,7 +1554,7 @@ readDollarExpression = do
 readDollarExp = arithmetic <|> readDollarExpansion <|> readDollarBracket <|> readDollarBraceCommandExpansion <|> readDollarBraced <|> readDollarVariable
   where
     arithmetic = readAmbiguous "$((" readDollarArithmetic readDollarExpansion (\pos ->
-        parseNoteAt pos WarningC 1102 "Shells disambiguate $(( differently or not at all. For $(command substition), add space after $( . For $((arithmetics)), fix parsing errors.")
+        parseNoteAt pos ErrorC 1102 "Shells disambiguate $(( differently or not at all. For $(command substition), add space after $( . For $((arithmetics)), fix parsing errors.")
 
 prop_readDollarSingleQuote = isOk readDollarSingleQuote "$'foo\\\'lol'"
 readDollarSingleQuote = called "$'..' expression" $ do
@@ -1733,6 +1746,7 @@ prop_readHereDoc14= isWarning readScript "cat << foo\nbar\nfoo \n"
 prop_readHereDoc15= isWarning readScript "cat <<foo\nbar\nfoo bar\nfoo"
 prop_readHereDoc16= isOk readScript "cat <<- ' foo'\nbar\n foo\n"
 prop_readHereDoc17= isWarning readScript "cat <<- ' foo'\nbar\n  foo\n foo\n"
+prop_readHereDoc18= isOk readScript "cat <<'\"foo'\nbar\n\"foo\n"
 prop_readHereDoc20= isWarning readScript "cat << foo\n  foo\n()\nfoo\n"
 prop_readHereDoc21= isOk readScript "# shellcheck disable=SC1039\ncat << foo\n  foo\n()\nfoo\n"
 readHereDoc = called "here document" $ do
@@ -1753,14 +1767,17 @@ readHereDoc = called "here document" $ do
     addPendingHereDoc doc
     return doc
   where
-    quotes = "\"'\\"
+    unquote :: String -> (Quoted, String)
+    unquote "" = (Unquoted, "")
+    unquote [c] = (Unquoted, [c])
+    unquote s@(cl:tl) =
+      case reverse tl of
+        (cr:tr) | cr == cl && cl `elem` "\"'" -> (Quoted, reverse tr)
+        _ -> (if '\\' `elem` s then (Quoted, filter ((/=) '\\') s) else (Unquoted, s))
     -- Fun fact: bash considers << foo"" quoted, but not << <("foo").
-    -- Instead of replicating this, just read a token and strip quotes.
     readToken = do
         str <- readStringForParser readNormalWord
-        return (if any (`elem` quotes) str then Quoted else Unquoted,
-                filter (not . (`elem` quotes)) str)
-
+        return $ unquote str
 
 readPendingHereDocs = do
     docs <- popPendingHereDocs
@@ -1809,7 +1826,7 @@ readPendingHereDocs = do
             let thereIsNoTrailer = null trailingSpace && null trailer
             let leaderIsOk = null leadingSpace
                     || dashed == Dashed && leadingSpacesAreTabs
-            let trailerStart = if null trailer then '\0' else head trailer
+            let trailerStart = case trailer of [] -> '\0'; (h:_) -> h
             let hasTrailingSpace = not $ null trailingSpace
             let hasTrailer = not $ null trailer
             let ppt = parseProblemAt trailerPos ErrorC
@@ -2035,7 +2052,11 @@ readSimpleCommand = called "simple command" $ do
 
       Just cmd -> do
             validateCommand cmd
-            suffix <- option [] $ getParser readCmdSuffix cmd [
+            -- We have to ignore possible parsing problems from the lookAhead parser
+            firstArgument <- ignoreProblemsOf . optionMaybe . try . lookAhead $ readCmdWord
+            suffix <- option [] $ getParser readCmdSuffix
+                    -- If `export` or other modifier commands are called with `builtin` we have to look at the first argument
+                    (if isCommand ["builtin"] cmd then fromMaybe cmd firstArgument else cmd) [
                         (["declare", "export", "local", "readonly", "typeset"], readModifierSuffix),
                         (["time"], readTimeSuffix),
                         (["let"], readLetSuffix),
@@ -2283,6 +2304,7 @@ prop_readIfClause2 = isWarning readIfClause "if false; then; echo oo; fi"
 prop_readIfClause3 = isWarning readIfClause "if false; then true; else; echo lol; fi"
 prop_readIfClause4 = isWarning readIfClause "if false; then true; else if true; then echo lol; fi; fi"
 prop_readIfClause5 = isOk readIfClause "if false; then true; else\nif true; then echo lol; fi; fi"
+prop_readIfClause6 = isWarning readIfClause "if true\nthen\nDo the thing\nfi"
 readIfClause = called "if expression" $ do
     start <- startSpan
     pos <- getPosition
@@ -2442,6 +2464,7 @@ readDoGroup kwId = do
 
 
 prop_readForClause = isOk readForClause "for f in *; do rm \"$f\"; done"
+prop_readForClause1 = isOk readForClause "for f in *; { rm \"$f\"; }"
 prop_readForClause3 = isOk readForClause "for f; do foo; done"
 prop_readForClause4 = isOk readForClause "for((i=0; i<10; i++)); do echo $i; done"
 prop_readForClause5 = isOk readForClause "for ((i=0;i<10 && n>x;i++,--n))\ndo \necho $i\ndone"
@@ -2481,7 +2504,7 @@ readForClause = called "for loop" $ do
             "Don't use $ on the iterator name in for loops."
         name <- readVariableName `thenSkip` allspacing
         values <- readInClause <|> (optional readSequentialSep >> return [])
-        group <- readDoGroup id
+        group <- readBraced <|> readDoGroup id
         return $ T_ForIn id name values group
 
 prop_readSelectClause1 = isOk readSelectClause "select foo in *; do echo $foo; done"
@@ -2519,6 +2542,7 @@ prop_readCaseClause2 = isOk readCaseClause "case foo\n in * ) echo bar;; esac"
 prop_readCaseClause3 = isOk readCaseClause "case foo\n in * ) echo bar & ;; esac"
 prop_readCaseClause4 = isOk readCaseClause "case foo\n in *) echo bar ;& bar) foo; esac"
 prop_readCaseClause5 = isOk readCaseClause "case foo\n in *) echo bar;;& foo) baz;; esac"
+prop_readCaseClause6 = isOk readCaseClause "case foo\n in if) :;; done) :;; esac"
 readCaseClause = called "case expression" $ do
     start <- startSpan
     g_Case
@@ -2642,14 +2666,14 @@ readCoProc = called "coproc" $ do
         return $ T_CoProcBody id body
 
 
-readPattern = (readNormalWord `thenSkip` spacing) `sepBy1` (char '|' `thenSkip` spacing)
+readPattern = (readPatternWord `thenSkip` spacing) `sepBy1` (char '|' `thenSkip` spacing)
 
 prop_readCompoundCommand = isOk readCompoundCommand "{ echo foo; }>/dev/null"
 readCompoundCommand = do
     cmd <- choice [
         readBraceGroup,
         readAmbiguous "((" readArithmeticExpression readSubshell (\pos ->
-            parseNoteAt pos WarningC 1105 "Shells disambiguate (( differently or not at all. For subshell, add spaces around ( . For ((, fix parsing errors."),
+            parseNoteAt pos ErrorC 1105 "Shells disambiguate (( differently or not at all. For subshell, add spaces around ( . For ((, fix parsing errors."),
         readSubshell,
         readCondition,
         readWhileClause,
@@ -2867,6 +2891,7 @@ redirToken c t = try $ do
 
 tryWordToken s t = tryParseWordToken s t `thenSkip` spacing
 tryParseWordToken keyword t = try $ do
+    pos <- getPosition
     start <- startSpan
     str <- anycaseString keyword
     id <- endSpan start
@@ -2882,9 +2907,10 @@ tryParseWordToken keyword t = try $ do
             _ -> return ()
 
     lookAhead keywordSeparator
-    when (str /= keyword) $
-        parseProblem ErrorC 1081 $
-            "Scripts are case sensitive. Use '" ++ keyword ++ "', not '" ++ str ++ "'."
+    when (str /= keyword) $ do
+        parseProblemAt pos ErrorC 1081 $
+            "Scripts are case sensitive. Use '" ++ keyword ++ "', not '" ++ str ++ "' (or quote if literal)."
+        fail ""
     return $ t id
 
 anycaseString =
@@ -3145,7 +3171,7 @@ readScriptFile sourced = do
             Nothing -> parseProblemAt pos ErrorC 1008 "This shebang was unrecognized. ShellCheck only supports sh/bash/dash/ksh. Add a 'shell' directive to specify."
 
     isValidShell s =
-        let good = s == "" || any (`isPrefixOf` s) goodShells
+        let good = null s || any (`isPrefixOf` s) goodShells
             bad = any (`isPrefixOf` s) badShells
         in
             if good
@@ -3425,4 +3451,3 @@ tryWithErrors parser = do
 
 return []
 runTests = $quickCheckAll
-

test/buildtest

@@ -11,21 +11,34 @@ command -v cabal ||
 
 cabal update ||
   die "can't update"
-cabal install --dependencies-only --enable-tests ||
+
+if [ -e /etc/arch-release ]
+then
+  # Arch has an unconventional packaging setup
+  flags=(--disable-library-vanilla --enable-shared --enable-executable-dynamic --ghc-options=-dynamic)
+else
+  flags=()
+fi
+
+cabal install --dependencies-only --enable-tests "${flags[@]}" ||
+  cabal install --dependencies-only "${flags[@]}" ||
     die "can't install dependencies"
-cabal configure --enable-tests ||
+cabal configure --enable-tests "${flags[@]}" ||
   die "configure failed"
 cabal build ||
   die "build failed"
 cabal test ||
   die "test failed"
 
-dist/build/shellcheck/shellcheck - << 'EOF' || die "execution failed"
+sc="$(find . -name shellcheck -type f -perm -111)"
+[ -x "$sc" ] || die "Can't find executable"
+
+"$sc" - << 'EOF' || die "execution failed"
 #!/bin/sh
 echo "Hello World"
 EOF
 
-dist/build/shellcheck/shellcheck - << 'EOF' && die "negative execution failed"
+"$sc" - << 'EOF' && die "negative execution failed"
 #!/bin/sh
 echo $1
 EOF

test/check_release

@@ -1,4 +1,5 @@
 #!/usr/bin/env bash
+# shellcheck disable=SC2257
 
 failed=0
 fail() {

test/distrotest

@@ -17,13 +17,13 @@ and is still highly experimental.
 Make sure you're plugged in and have screen/tmux in place,
 then re-run with $0 --run to continue.
 
-Also note that 'dist' will be deleted.
+Also note that dist* will be deleted.
 EOF
 exit 0
 }
 
-echo "Deleting 'dist'..."
-rm -rf dist
+echo "Deleting 'dist' and 'dist-newstyle'..."
+rm -rf dist dist-newstyle
 
 log=$(mktemp) || die "Can't create temp file"
 date >> "$log" || die "Can't write to log"
@@ -61,20 +61,16 @@ done << EOF
 debian:stable         apt-get update && apt-get install -y cabal-install
 debian:testing        apt-get update && apt-get install -y cabal-install
 ubuntu:latest         apt-get update && apt-get install -y cabal-install
+haskell:latest        true
 opensuse/leap:latest  zypper install -y cabal-install ghc
+fedora:latest         dnf install -y cabal-install ghc-template-haskell-devel findutils
+archlinux/base:latest pacman -S -y --noconfirm cabal-install ghc-static base-devel
 
-# Other Ubuntu versions we want to support
-ubuntu:19.04          apt-get update && apt-get install -y cabal-install
-ubuntu:18.10          apt-get update && apt-get install -y cabal-install
+# Other versions we want to support
+ubuntu:18.04          apt-get update && apt-get install -y cabal-install
 
 # Misc Haskell including current and latest Stack build
-ubuntu:18.10          set -e; apt-get update && apt-get install -y curl && curl -sSL https://get.haskellstack.org/ | sh -s - -f && cd /mnt && exec test/stacktest
-haskell:latest        true
-
-# Known to currently fail
-centos:latest         yum install -y epel-release && yum install -y cabal-install
-fedora:latest         dnf install -y cabal-install
-archlinux/base:latest pacman -S -y --noconfirm cabal-install ghc-static base-devel
+ubuntu:18.04          set -e; apt-get update && apt-get install -y curl && curl -sSL https://get.haskellstack.org/ | sh -s - -f && cd /mnt && exec test/stacktest
 EOF
 
 exit "$final"