module ShellCheck.Analytics (AnalysisOption(..), filterByAnnotation, runAnalytics, shellForExecutable) where

import ShellCheck.AST

import ShellCheck.Data

import ShellCheck.Parser

import Control.Monad

import Control.Monad.State

import Control.Monad.Writer

import qualified Data.Map as Map

import Data.Char

import Data.Functor

import Data.List

import Data.Maybe

import Debug.Trace

import Text.Regex

import Data.Maybe

data Shell = Ksh | Zsh | Sh | Bash

deriving (Show, Eq)

data Parameters = Parameters {

variableFlow :: [StackData],

parentMap :: Map.Map Id Token,

shellType :: Shell

}

data AnalysisOption = ForceShell Shell

treeChecks :: [Parameters -> Token -> [Note]]

treeChecks = [

runNodeAnalysis

(\p t -> mapM_ (\f -> f t) $

map (\f -> f p) (nodeChecks ++ (checksFor (shellType p))))

,subshellAssignmentCheck

,checkSpacefulness

,checkQuotesInLiterals

,checkShebang

,checkFunctionsUsedExternally

,checkUnusedAssignments

]

checksFor Sh = [

checkBashisms

,checkTimeParameters

]

checksFor Ksh = [

checkEchoSed

]

checksFor Zsh = [

checkTimeParameters

,checkEchoSed

]

checksFor Bash = [

checkTimeParameters

,checkBraceExpansionVars

,checkEchoSed

]

runAnalytics :: [AnalysisOption] -> Token -> [Note]

runAnalytics options root = runList options root treeChecks

runList options root list = notes

where

params = Parameters {

shellType = getShellOption,

parentMap = getParentTree root,

variableFlow = getVariableFlow (shellType params) (parentMap params) root

}

notes = concatMap (\f -> f params root) list

getShellOption =

fromMaybe (determineShell root) . msum $

map ((\option ->

case option of

ForceShell x -> return x

)) options

checkList l t = concatMap (\f -> f t) l

prop_determineShell0 = determineShell (T_Script (Id 0) "#!/bin/sh" []) == Sh

prop_determineShell1 = determineShell (T_Script (Id 0) "#!/usr/bin/env ksh" []) == Ksh

prop_determineShell2 = determineShell (T_Script (Id 0) "" []) == Bash

determineShell (T_Script _ shebang _) = fromMaybe Bash . shellForExecutable $ shellFor shebang

where shellFor s | "/env " `isInfixOf` s = head ((drop 1 $ words s)++[""])

shellFor s = reverse . takeWhile (/= '/') . reverse $ s

shellForExecutable "sh" = return Sh

shellForExecutable "ash" = return Sh

shellForExecutable "dash" = return Sh

shellForExecutable "ksh" = return Ksh

shellForExecutable "ksh88" = return Ksh

shellForExecutable "ksh93" = return Ksh

shellForExecutable "zsh" = return Zsh

shellForExecutable "bash" = return Bash

shellForExecutable _ = Nothing

runNodeAnalysis f p t = execWriter (doAnalysis (f p) t)

nodeChecks = [

checkUuoc

,checkPipePitfalls

,checkForInQuoted

,checkForInLs

,checkShorthandIf

,checkDollarStar

,checkUnquotedDollarAt

,checkStderrRedirect

,checkUnquotedN

,checkNumberComparisons

,checkSingleBracketOperators

,checkDoubleBracketOperators

,checkNoaryWasBinary

,checkConstantNoary

,checkForDecimals

,checkDivBeforeMult

,checkArithmeticDeref

,checkArithmeticBadOctal

,checkComparisonAgainstGlob

,checkPrintfVar

,checkCommarrays

,checkOrNeq

,checkEchoWc

,checkConstantIfs

,checkTr

,checkPipedAssignment

,checkAssignAteCommand

,checkUuoe

,checkFindNameGlob

,checkGrepRe

,checkNeedlessCommands

,checkQuotedCondRegex

,checkForInCat

,checkFindExec

,checkValidCondOps

,checkGlobbedRegex

,checkTrapQuotes

,checkTestRedirects

,checkIndirectExpansion

,checkSudoRedirect

,checkPS1Assignments

,checkBackticks

,checkInexplicablyUnquoted

,checkTildeInQuotes

,checkLonelyDotDash

,checkSpuriousExec

,checkSpuriousExpansion

,checkUnusedEchoEscapes

,checkDollarBrackets

,checkSshHereDoc

,checkSshCommandString

,checkGlobsAsOptions

,checkWhileReadPitfalls

,checkArithmeticOpCommand

,checkCharRangeGlob

,checkUnquotedExpansions

,checkSingleQuotedVariables

,checkRedirectToSame

,checkPrefixAssignmentReference

,checkLoopKeywordScope

,checkCdAndBack

,checkWrongArithmeticAssignment

,checkConditionalAndOrs

,checkFunctionDeclarations

,checkCatastrophicRm

]

filterByAnnotation token notes =

filter (not . shouldIgnore) notes

where

numFor (Note _ _ code _) = code

idFor (Note id _ _ _) = id

shouldIgnore note =

any (shouldIgnoreFor (numFor note)) $

getPath parents (T_Bang $ idFor note)

shouldIgnoreFor num (T_Annotation _ anns _) =

any hasNum anns

where

hasNum (DisableComment ts) = num == ts

shouldIgnoreFor _ _ = False

parents = getParentTree token

addNote note = tell [note]

makeNote severity id code note = addNote $ Note id severity code note

warn = makeNote WarningC

err = makeNote ErrorC

info = makeNote InfoC

style = makeNote StyleC

isVariableStartChar x = x == '_' || x >= 'a' && x <= 'z' || x >= 'A' && x <= 'Z'

isVariableChar x = isVariableStartChar x || x >= '0' && x <= '9'

prop_isVariableName1 = isVariableName "_fo123"

prop_isVariableName2 = not $ isVariableName "4"

prop_isVariableName3 = not $ isVariableName "test: "

isVariableName (x:r) = isVariableStartChar x && all isVariableChar r

isVariableName _ = False

willSplit x =

case x of

T_DollarBraced _ _ -> True

T_DollarExpansion _ _ -> True

T_Backticked _ _ -> True

T_BraceExpansion _ s -> True

T_Glob _ _ -> True

T_Extglob _ _ _ -> True

T_NormalWord _ l -> any willSplit l

_ -> False

isGlob (T_Extglob _ _ _) = True

isGlob (T_Glob _ _) = True

isGlob (T_NormalWord _ l) = any isGlob l

isGlob _ = False

wouldHaveBeenGlob s = '*' `elem` s

isConfusedGlobRegex ('*':_) = True

isConfusedGlobRegex [x,'*'] | x /= '\\' = True

isConfusedGlobRegex _ = False

isPotentiallyConfusedGlobRegex =

let re = mkRegex "[a-z1-9]\\*" in

isJust . matchRegex re

matches string regex = isJust $ matchRegex regex string

headOrDefault _ (a:_) = a

headOrDefault def _ = def

isConstant token =

case token of

T_NormalWord _ l -> all isConstant l

T_DoubleQuoted _ l -> all isConstant l

T_SingleQuoted _ _ -> True

T_Literal _ _ -> True

_ -> False

isEmpty token =

case token of

T_NormalWord _ l -> all isEmpty l

T_DoubleQuoted _ l -> all isEmpty l

T_SingleQuoted _ "" -> True

T_Literal _ "" -> True

_ -> False

makeSimple (T_NormalWord _ [f]) = f

makeSimple (T_Redirecting _ _ f) = f

makeSimple (T_Annotation _ _ f) = f

makeSimple t = t

simplify = doTransform makeSimple

deadSimple (T_NormalWord _ l) = [concat (concatMap (deadSimple) l)]

deadSimple (T_DoubleQuoted _ l) = [(concat (concatMap (deadSimple) l))]

deadSimple (T_SingleQuoted _ s) = [s]

deadSimple (T_DollarBraced _ _) = ["${VAR}"]

deadSimple (T_DollarArithmetic _ _) = ["${VAR}"]

deadSimple (T_DollarExpansion _ _) = ["${VAR}"]

deadSimple (T_Backticked _ _) = ["${VAR}"]

deadSimple (T_Glob _ s) = [s]

deadSimple (T_Pipeline _ [x]) = deadSimple x

deadSimple (T_Literal _ x) = [x]

deadSimple (T_SimpleCommand _ vars words) = concatMap (deadSimple) words

deadSimple (T_Redirecting _ _ foo) = deadSimple foo

deadSimple (T_DollarSingleQuoted _ s) = [s]

deadSimple (T_Annotation _ _ s) = deadSimple s

deadSimple _ = []

(!!!) list i =

case drop i list of

[] -> Nothing

(r:_) -> Just r

verify f s = checkNode f s == Just True

verifyNot f s = checkNode f s == Just False

verifyTree f s = checkTree f s == Just True

verifyNotTree f s = checkTree f s == Just False

checkNode f s = checkTree (runNodeAnalysis f) s

checkTree f s = case parseShell "-" s of

(ParseResult (Just (t, m)) _) -> Just . not . null $ runList [] t [f]

_ -> Nothing

prop_checkEchoWc3 = verify checkEchoWc "n=$(echo $foo | wc -c)"

checkEchoWc _ (T_Pipeline id [a, b]) =

when (acmd == ["echo", "${VAR}"]) $

case bcmd of

["wc", "-c"] -> countMsg

["wc", "-m"] -> countMsg

_ -> return ()

where

acmd = deadSimple a

bcmd = deadSimple b

countMsg = style id 2000 $ "See if you can use ${#variable} instead."

checkEchoWc _ _ = return ()

prop_checkEchoSed1 = verify checkEchoSed "FOO=$(echo \"$cow\" | sed 's/foo/bar/g')"

prop_checkEchoSed2 = verify checkEchoSed "rm $(echo $cow | sed -e 's,foo,bar,')"

checkEchoSed _ (T_Pipeline id [a, b]) =

when (acmd == ["echo", "${VAR}"]) $

case bcmd of

["sed", v] -> checkIn v

["sed", "-e", v] -> checkIn v

_ -> return ()

where

sedRe = mkRegex "^s(.)(.*)\\1(.*)\\1g?$"

acmd = deadSimple a

bcmd = deadSimple b

checkIn s =

case matchRegex sedRe s of

Just _ -> style id 2001 $ "See if you can use ${variable//search/replace} instead."

_ -> return ()

checkEchoSed _ _ = return ()

prop_checkPipedAssignment1 = verify checkPipedAssignment "A=ls | grep foo"

prop_checkPipedAssignment2 = verifyNot checkPipedAssignment "A=foo cmd | grep foo"

prop_checkPipedAssignment3 = verifyNot checkPipedAssignment "A=foo"

checkPipedAssignment _ (T_Pipeline _ (T_Redirecting _ _ (T_SimpleCommand id (_:_) []):_:_)) =

warn id 2036 "If you wanted to assign the output of the pipeline, use a=$(b | c) ."

checkPipedAssignment _ _ = return ()

prop_checkAssignAteCommand1 = verify checkAssignAteCommand "A=ls -l"

prop_checkAssignAteCommand2 = verify checkAssignAteCommand "A=ls --sort=$foo"

prop_checkAssignAteCommand3 = verify checkAssignAteCommand "A=cat foo | grep bar"

prop_checkAssignAteCommand4 = verifyNot checkAssignAteCommand "A=foo ls -l"

prop_checkAssignAteCommand5 = verifyNot checkAssignAteCommand "PAGER=cat grep bar"

checkAssignAteCommand _ (T_SimpleCommand id ((T_Assignment _ _ _ _ assignmentTerm):[]) (firstWord:_)) =

when ("-" `isPrefixOf` (concat $ deadSimple firstWord) ||

(isCommonCommand (getLiteralString assignmentTerm)

&& not (isCommonCommand (getLiteralString firstWord)))) $

warn id 2037 "To assign the output of a command, use var=$(cmd) ."

where

isCommonCommand (Just s) = s `elem` commonCommands

isCommonCommand _ = False

checkAssignAteCommand _ _ = return ()

prop_checkArithmeticOpCommand1 = verify checkArithmeticOpCommand "i=i + 1"

prop_checkArithmeticOpCommand2 = verify checkArithmeticOpCommand "foo=bar * 2"

prop_checkArithmeticOpCommand3 = verifyNot checkArithmeticOpCommand "foo + opts"

checkArithmeticOpCommand _ (T_SimpleCommand id ((T_Assignment _ _ _ _ _):[]) (firstWord:_)) =

fromMaybe (return ()) $ check <$> getGlobOrLiteralString firstWord

where

check op =

when (op `elem` ["+", "-", "*", "/"]) $

warn (getId firstWord) 2099 $

"Use $((..)) for arithmetics, e.g. i=$((i " ++ op ++ " 2))"

checkArithmeticOpCommand _ _ = return ()

prop_checkWrongArit = verify checkWrongArithmeticAssignment "i=i+1"

prop_checkWrongArit2 = verify checkWrongArithmeticAssignment "n=2; i=n*2"

checkWrongArithmeticAssignment params (T_SimpleCommand id ((T_Assignment _ _ _ _ val):[]) []) =

fromMaybe (return ()) $ do

str <- getNormalString val

match <- matchRegex regex str

var <- match !!! 0

op <- match !!! 1

Map.lookup var references

return $ do

warn (getId val) 2100 $

"Use $((..)) for arithmetics, e.g. i=$((i " ++ op ++ " 2))"

where

regex = mkRegex "^([_a-zA-Z][_a-zA-Z0-9]*)([+*-]).+$"

references = foldl (flip ($)) Map.empty (map insertRef $ variableFlow params)

insertRef (Assignment (_, _, name, _)) =

Map.insert name ()

insertRef _ = Prelude.id

getNormalString (T_NormalWord _ words) = do

parts <- foldl (liftM2 (\x y -> x ++ [y])) (Just []) $ map getLiterals words

return $ concat parts

getNormalString _ = Nothing

getLiterals (T_Literal _ s) = return s

getLiterals (T_Glob _ s) = return s

getLiterals _ = Nothing

checkWrongArithmeticAssignment _ _ = return ()

prop_checkUuoc1 = verify checkUuoc "cat foo | grep bar"

prop_checkUuoc2 = verifyNot checkUuoc "cat * | grep bar"

prop_checkUuoc3 = verify checkUuoc "cat $var | grep bar"

prop_checkUuoc4 = verifyNot checkUuoc "cat $var"

checkUuoc _ (T_Pipeline _ ((T_Redirecting _ _ cmd):_:_)) = checkCommand "cat" f cmd

where

f [word] = when (isSimple word) $

style (getId word) 2002 "Useless cat. Consider 'cmd < file | ..' or 'cmd file | ..' instead."

f _ = return ()

isSimple (T_NormalWord _ parts) = all isSimple parts

isSimple (T_DollarBraced _ _) = True

isSimple x = not $ willSplit x

checkUuoc _ _ = return ()

prop_checkNeedlessCommands = verify checkNeedlessCommands "foo=$(expr 3 + 2)"

prop_checkNeedlessCommands2 = verify checkNeedlessCommands "foo=`echo \\`expr 3 + 2\\``"

prop_checkNeedlessCommands3 = verifyNot checkNeedlessCommands "foo=$(expr foo : regex)"

checkNeedlessCommands _ cmd@(T_SimpleCommand id _ _) |

cmd `isCommand` "expr" && (not $ ":" `elem` deadSimple cmd) =

style id 2003 "expr is antiquated. Consider rewriting this using $((..)), ${} or [[ ]]."

checkNeedlessCommands _ _ = return ()

prop_checkPipePitfalls3 = verify checkPipePitfalls "ls | grep -v mp3"

prop_checkPipePitfalls4 = verifyNot checkPipePitfalls "find . -print0 | xargs -0 foo"

prop_checkPipePitfalls5 = verifyNot checkPipePitfalls "ls -N | foo"

prop_checkPipePitfalls6 = verify checkPipePitfalls "find . | xargs foo"

checkPipePitfalls _ (T_Pipeline id commands) = do

for ["find", "xargs"] $

\(find:xargs:_) -> let args = deadSimple xargs in

when (not $ hasShortParameter args '0') $

warn (getId find) 2038 "Use either 'find .. -print0 | xargs -0 ..' or 'find .. -exec .. +' to allow for non-alphanumeric filenames."

for ["?", "echo"] $

\(_:echo:_) -> info (getId echo) 2008 "echo doesn't read from stdin, are you sure you should be piping to it?"

for' ["ps", "grep"] $

\x -> info x 2009 "Consider using pgrep instead of grepping ps output."

didLs <- liftM or . sequence $ [

for' ["ls", "grep"] $

\x -> warn x 2010 "Don't use ls | grep. Use a glob or a for loop with a condition to allow non-alphanumeric filenames.",

for' ["ls", "xargs"] $

\x -> warn x 2011 "Use 'find .. -print0 | xargs -0 ..' or 'find .. -exec .. +' to allow non-alphanumeric filenames."

]

when (not didLs) $ do

for ["ls", "?"] $

\(ls:_) -> (when (not $ hasShortParameter (deadSimple ls) 'N') $

info (getId ls) 2012 "Use find instead of ls to better handle non-alphanumeric filenames.")

return ()

where

for l f =

let indices = indexOfSublists l (map (headOrDefault "" . deadSimple) commands)

in do

mapM_ f (map (\n -> take (length l) $ drop n $ commands) indices)

return . not . null $ indices

for' l f = for l (first f)

first func (x:_) = func (getId x)

first _ _ = return ()

hasShortParameter list char = any (\x -> "-" `isPrefixOf` x && char `elem` x) list

checkPipePitfalls _ _ = return ()

indexOfSublists sub all = f 0 all

where

f _ [] = []

f n a@(r:rest) =

let others = f (n+1) rest in

if match sub a

then n:others

else others

match ("?":r1) (_:r2) = match r1 r2

match (x1:r1) (x2:r2) | x1 == x2 = match r1 r2

match [] _ = True

match _ _ = False

bracedString l = concat $ deadSimple l

isMagicInQuotes (T_DollarBraced _ l) | '@' `elem` (bracedString l) = True

isMagicInQuotes _ = False

prop_checkShebang1 = verifyTree checkShebang "#!/usr/bin/env bash -x\necho cow"

prop_checkShebang2 = verifyNotTree checkShebang "#! /bin/sh -l "

checkShebang _ (T_Script id sb _) =

if (length $ words sb) > 2 then

[Note id ErrorC 2096 $ "On most OS, shebangs can only specify a single parameter."]

else []

prop_checkBashisms = verify checkBashisms "while read a; do :; done < <(a)"

prop_checkBashisms2 = verify checkBashisms "[ foo -nt bar ]"

prop_checkBashisms3 = verify checkBashisms "echo $((i++))"

prop_checkBashisms4 = verify checkBashisms "rm !(*.hs)"

prop_checkBashisms5 = verify checkBashisms "source file"

prop_checkBashisms6 = verify checkBashisms "[ \"$a\" == 42 ]"

prop_checkBashisms7 = verify checkBashisms "echo ${var[1]}"

prop_checkBashisms8 = verify checkBashisms "echo ${!var[@]}"

prop_checkBashisms9 = verify checkBashisms "echo ${!var*}"

prop_checkBashisms10= verify checkBashisms "echo ${var:4:12}"

prop_checkBashisms11= verifyNot checkBashisms "echo ${var:-4}"

prop_checkBashisms12= verify checkBashisms "echo ${var//foo/bar}"

prop_checkBashisms13= verify checkBashisms "exec -c env"

prop_checkBashisms14= verify checkBashisms "echo -n \"Foo: \""

prop_checkBashisms15= verify checkBashisms "let n++"

prop_checkBashisms16= verify checkBashisms "echo $RANDOM"

prop_checkBashisms17= verify checkBashisms "echo $((RANDOM%6+1))"

prop_checkBashisms18= verify checkBashisms "foo &> /dev/null"

checkBashisms _ = bashism

where

errMsg id s = err id 2040 $ "#!/bin/sh was specified, so " ++ s ++ " is not supported, even when sh is actually bash."

warnMsg id s = warn id 2039 $ "#!/bin/sh was specified, but " ++ s ++ " is not standard."

bashism (T_ProcSub id _ _) = errMsg id "process substitution"

bashism (T_Extglob id _ _) = warnMsg id "extglob"

bashism (T_DollarSingleQuoted id _) = warnMsg id "$'..'"

bashism (T_DollarDoubleQuoted id _) = warnMsg id "$\"..\""

bashism (T_ForArithmetic id _ _ _ _) = warnMsg id "arithmetic for loop"

bashism (T_Arithmetic id _) = warnMsg id "standalone ((..))"

bashism (T_DollarBracket id _) = warnMsg id "$[..] in place of $((..))"

bashism (T_SelectIn id _ _ _) = warnMsg id "select loop"

bashism (T_BraceExpansion id _) = warnMsg id "brace expansion"

bashism (T_Condition id DoubleBracket _) = warnMsg id "[[ ]]"

bashism (T_HereString id _) = warnMsg id "here-string"

bashism (TC_Binary id SingleBracket op _ _)

| op `elem` [ "-nt", "-ef", "\\<", "\\>", "==" ] =

warnMsg id op

bashism (TA_Unary id op _)

| op `elem` [ "|++", "|--", "++|", "--|"] =

warnMsg id (filter (/= '|') op)

bashism t@(T_SimpleCommand id _ _)

| t `isCommand` "source" =

warnMsg id "'source' in place of '.'"

bashism (T_FdRedirect id "&" (T_IoFile _ (T_Greater _) _)) = warnMsg id "&>"

bashism (T_DollarBraced id token) =

mapM_ check expansion

where

str = concat $ deadSimple token

check (regex, feature) =

when (isJust $ matchRegex regex str) $ warnMsg id feature

bashism t@(T_SimpleCommand _ _ (cmd:arg:_))

| t `isCommand` "echo" && "-" `isPrefixOf` argString =

when (not $ "--" `isPrefixOf` argString) $ -- echo "-------"

warnMsg (getId arg) "echo flag"

where argString = (concat $ deadSimple arg)

bashism t@(T_SimpleCommand _ _ (cmd:arg:_))

| t `isCommand` "exec" && "-" `isPrefixOf` (concat $ deadSimple arg) =

warnMsg (getId arg) "exec flag"

bashism t@(T_SimpleCommand id _ _)

| t `isCommand` "let" = warnMsg id "'let'"

bashism t@(TA_Variable id "RANDOM") =

warnMsg id "RANDOM"

bashism _ = return()

varChars="_0-9a-zA-Z"

expansion = let re = mkRegex in [

(re $ "^[" ++ varChars ++ "]+\\[.*\\]$", "array references"),

(re $ "^![" ++ varChars ++ "]+\\[[*@]]$", "array key expansion"),

(re $ "^![" ++ varChars ++ "]+[*@]$", "name matching prefix"),

(re $ "^[" ++ varChars ++ "]+:[^-=?+]", "string indexing"),

(re $ "^[" ++ varChars ++ "]+(\\[.*\\])?/", "string replacement"),

(re $ "^RANDOM$", "$RANDOM")

]

prop_checkForInQuoted = verify checkForInQuoted "for f in \"$(ls)\"; do echo foo; done"

prop_checkForInQuoted2 = verifyNot checkForInQuoted "for f in \"$@\"; do echo foo; done"

prop_checkForInQuoted2a = verifyNot checkForInQuoted "for f in *.mp3; do echo foo; done"

prop_checkForInQuoted2b = verify checkForInQuoted "for f in \"*.mp3\"; do echo foo; done"

prop_checkForInQuoted3 = verify checkForInQuoted "for f in 'find /'; do true; done"

prop_checkForInQuoted4 = verify checkForInQuoted "for f in 1,2,3; do true; done"

prop_checkForInQuoted4a = verifyNot checkForInQuoted "for f in foo{1,2,3}; do true; done"

prop_checkForInQuoted5 = verify checkForInQuoted "for f in ls; do true; done"

checkForInQuoted _ (T_ForIn _ f [T_NormalWord _ [word@(T_DoubleQuoted id list)]] _) =

when (any (\x -> willSplit x && not (isMagicInQuotes x)) list

|| (getLiteralString word >>= (return . wouldHaveBeenGlob)) == Just True) $

err id 2066 $ "Since you double quoted this, it will not word split, and the loop will only run once."

checkForInQuoted _ (T_ForIn _ f [T_NormalWord _ [T_SingleQuoted id s]] _) =

warn id 2041 $ "This is a literal string. To run as a command, use $(" ++ s ++ ")."

checkForInQuoted _ (T_ForIn _ f [T_NormalWord _ [T_Literal id s]] _) =

if ',' `elem` s

then when (not $ '{' `elem` s) $

warn id 2042 $ "Use spaces, not commas, to separate loop elements."

else warn id 2043 $ "This loop will only run once, with " ++ f ++ "='" ++ s ++ "'."

checkForInQuoted _ _ = return ()

prop_checkForInCat1 = verify checkForInCat "for f in $(cat foo); do stuff; done"

prop_checkForInCat1a= verify checkForInCat "for f in `cat foo`; do stuff; done"

prop_checkForInCat2 = verify checkForInCat "for f in $(cat foo | grep lol); do stuff; done"

prop_checkForInCat2a= verify checkForInCat "for f in `cat foo | grep lol`; do stuff; done"

prop_checkForInCat3 = verifyNot checkForInCat "for f in $(cat foo | grep bar | wc -l); do stuff; done"

checkForInCat _ (T_ForIn _ f [T_NormalWord _ w] _) = mapM_ checkF w

where

checkF (T_DollarExpansion id [T_Pipeline _ r])

| all isLineBased r =

info id 2013 "To read lines rather than words, pipe/redirect to a 'while read' loop."

checkF (T_Backticked id cmds) = checkF (T_DollarExpansion id cmds)

checkF _ = return ()

isLineBased cmd = any (cmd `isCommand`)

["grep", "fgrep", "egrep", "sed", "cat", "awk", "cut", "sort"]

checkForInCat _ _ = return ()

prop_checkForInLs = verify checkForInLs "for f in $(ls *.mp3); do mplayer \"$f\"; done"

prop_checkForInLs2 = verify checkForInLs "for f in `ls *.mp3`; do mplayer \"$f\"; done"

prop_checkForInLs3 = verify checkForInLs "for f in `find / -name '*.mp3'`; do mplayer \"$f\"; done"

checkForInLs _ t = try t

where

try (T_ForIn _ f [T_NormalWord _ [T_DollarExpansion id [x]]] _) =

check id f x

try (T_ForIn _ f [T_NormalWord _ [T_Backticked id [x]]] _) =

check id f x

try _ = return ()

check id f x =

case deadSimple x of

("ls":n) ->

let warntype = if any ("-" `isPrefixOf`) n then warn else err in

warntype id 2045 $ "Iterate over globs whenever possible (e.g. 'for f in */*.wav'), as for loops over ls will fail for filenames like 'my file*.txt'."

("find":_) -> warn id 2044 $ "Use find -exec or a while read loop instead, as for loops over find will fail for filenames like 'my file*.txt'."

_ -> return ()

prop_checkFindExec1 = verify checkFindExec "find / -name '*.php' -exec rm {};"

prop_checkFindExec2 = verify checkFindExec "find / -exec touch {} && ls {} \\;"

prop_checkFindExec3 = verify checkFindExec "find / -execdir cat {} | grep lol +"

prop_checkFindExec4 = verifyNot checkFindExec "find / -name '*.php' -exec foo {} +"

prop_checkFindExec5 = verifyNot checkFindExec "find / -execdir bash -c 'a && b' \\;"

prop_checkFindExec6 = verify checkFindExec "find / -type d -execdir rm *.jpg \\;"

checkFindExec _ cmd@(T_SimpleCommand _ _ t@(h:r)) | cmd `isCommand` "find" = do

c <- broken r False

when c $ do

let wordId = getId $ last t in

err wordId 2067 "Missing ';' or + terminating -exec. You can't use |/||/&&, and ';' has to be a separate, quoted argument."

where

broken [] v = return v

broken (w:r) v = do

when v $ (mapM_ warnFor $ fromWord w)

case getLiteralString w of

Just "-exec" -> broken r True

Just "-execdir" -> broken r True

Just "+" -> broken r False

Just ";" -> broken r False

_ -> broken r v

shouldWarn x =

case x of

T_DollarExpansion _ _ -> True

T_Backticked _ _ -> True

T_Glob _ _ -> True

T_Extglob _ _ _ -> True

_ -> False

warnFor x =

if shouldWarn x

then info (getId x) 2014 "This will expand once before find runs, not per file found."

else return ()

fromWord (T_NormalWord _ l) = l

fromWord _ = []

checkFindExec _ _ = return ()

prop_checkUnquotedExpansions1 = verify checkUnquotedExpansions "rm $(ls)"

prop_checkUnquotedExpansions1a= verify checkUnquotedExpansions "rm `ls`"

prop_checkUnquotedExpansions2 = verify checkUnquotedExpansions "rm foo$(date)"

prop_checkUnquotedExpansions3 = verify checkUnquotedExpansions "[ $(foo) == cow ]"

prop_checkUnquotedExpansions3a= verify checkUnquotedExpansions "[ ! $(foo) ]"

prop_checkUnquotedExpansions4 = verifyNot checkUnquotedExpansions "[[ $(foo) == cow ]]"

prop_checkUnquotedExpansions5 = verifyNot checkUnquotedExpansions "for f in $(cmd); do echo $f; done"

prop_checkUnquotedExpansions6 = verifyNot checkUnquotedExpansions "$(cmd)"

prop_checkUnquotedExpansions7 = verifyNot checkUnquotedExpansions "cat << foo\n$(ls)\nfoo"

checkUnquotedExpansions params t =

check t

where

check t@(T_DollarExpansion _ _) = examine t

check t@(T_Backticked _ _) = examine t

check _ = return ()

tree = parentMap params

examine t =

unless (inUnquotableContext tree t || usedAsCommandName tree t) $

warn (getId t) 2046 "Quote this to prevent word splitting."

prop_checkRedirectToSame = verify checkRedirectToSame "cat foo > foo"

prop_checkRedirectToSame2 = verify checkRedirectToSame "cat lol | sed -e 's/a/b/g' > lol"

prop_checkRedirectToSame3 = verifyNot checkRedirectToSame "cat lol | sed -e 's/a/b/g' > foo.bar && mv foo.bar lol"

prop_checkRedirectToSame4 = verifyNot checkRedirectToSame "foo /dev/null > /dev/null"

prop_checkRedirectToSame5 = verifyNot checkRedirectToSame "foo > bar 2> bar"

checkRedirectToSame params s@(T_Pipeline _ list) =

mapM_ (\l -> (mapM_ (\x -> doAnalysis (checkOccurences x) l) (getAllRedirs list))) list

where

note x = Note x InfoC 2094 $

"Make sure not to read and write the same file in the same pipeline."

checkOccurences t@(T_NormalWord exceptId x) u@(T_NormalWord newId y) =

when (exceptId /= newId

&& x == y

&& not (isOutput t && isOutput u)

&& not (special t)) $ do

addNote $ note newId

addNote $ note exceptId

checkOccurences _ _ = return ()

getAllRedirs l = concatMap (\(T_Redirecting _ ls _) -> concatMap getRedirs ls) l

getRedirs (T_FdRedirect _ _ (T_IoFile _ op file)) =

case op of T_Greater _ -> [file]

T_Less _ -> [file]

T_DGREAT _ -> [file]

_ -> []

getRedirs _ = []

special x = "/dev/" `isPrefixOf` (concat $ deadSimple x)

isOutput t =

case drop 1 $ getPath (parentMap params) t of

(T_IoFile _ op _):_ ->

case op of

T_Greater _ -> True

T_DGREAT _ -> True

_ -> False

_ -> False

checkRedirectToSame _ _ = return ()

prop_checkShorthandIf = verify checkShorthandIf "[[ ! -z file ]] && scp file host || rm file"

prop_checkShorthandIf2 = verifyNot checkShorthandIf "[[ ! -z file ]] && { scp file host || echo 'Eek'; }"

prop_checkShorthandIf3 = verifyNot checkShorthandIf "foo && bar || echo baz"

prop_checkShorthandIf4 = verifyNot checkShorthandIf "foo && a=b || a=c"

checkShorthandIf _ (T_AndIf id _ (T_OrIf _ _ (T_Pipeline _ t)))

| not $ isOk t =

info id 2015 "Note that A && B || C is not if-then-else. C may run when A is true."

where

isOk [t] = isAssignment t || (fromMaybe False $ do

name <- getCommandBasename t

return $ name `elem` ["echo", "exit"])

isOk _ = False

checkShorthandIf _ _ = return ()

prop_checkDollarStar = verify checkDollarStar "for f in $*; do ..; done"

checkDollarStar _ (T_NormalWord _ [(T_DollarBraced id l)]) | (bracedString l) == "*" =

warn id 2048 $ "Use \"$@\" (with quotes) to prevent whitespace problems."

checkDollarStar _ _ = return ()

prop_checkUnquotedDollarAt = verify checkUnquotedDollarAt "ls $@"

prop_checkUnquotedDollarAt1= verifyNot checkUnquotedDollarAt "ls ${#@}"

prop_checkUnquotedDollarAt2 = verify checkUnquotedDollarAt "ls ${foo[@]}"

prop_checkUnquotedDollarAt3 = verifyNot checkUnquotedDollarAt "ls ${#foo[@]}"

prop_checkUnquotedDollarAt4 = verifyNot checkUnquotedDollarAt "ls \"$@\""

prop_checkUnquotedDollarAt5 = verifyNot checkUnquotedDollarAt "ls ${foo/@/ at }"

checkUnquotedDollarAt _ (T_NormalWord _ [T_DollarBraced id l]) =

let string = bracedString l

failing = err id 2068 $ "Add double quotes around ${" ++ string ++ "}, otherwise it's just like $* and breaks on spaces."

in do

when ("@" `isPrefixOf` string) failing

when (not ("#" `isPrefixOf` string) && "[@]" `isInfixOf` string) failing

checkUnquotedDollarAt _ _ = return ()

prop_checkStderrRedirect = verify checkStderrRedirect "test 2>&1 > cow"

prop_checkStderrRedirect2 = verifyNot checkStderrRedirect "test > cow 2>&1"

checkStderrRedirect _ (T_Redirecting _ [

T_FdRedirect id "2" (T_IoFile _ (T_GREATAND _) (T_NormalWord _ [T_Literal _ "1"])),

T_FdRedirect _ _ (T_IoFile _ op _)

] _) = case op of

T_Greater _ -> error

T_DGREAT _ -> error

_ -> return ()

where error = err id 2069 $ "The order of the 2>&1 and the redirect matters. The 2>&1 has to be last."

checkStderrRedirect _ _ = return ()

lt x = trace ("FAILURE " ++ (show x)) x

ltt t x = trace ("FAILURE " ++ (show t)) x

prop_checkSingleQuotedVariables = verify checkSingleQuotedVariables "echo '$foo'"

prop_checkSingleQuotedVariables2 = verify checkSingleQuotedVariables "echo 'lol$1.jpg'"

prop_checkSingleQuotedVariables3 = verifyNot checkSingleQuotedVariables "sed 's/foo$/bar/'"

prop_checkSingleQuotedVariables3a= verify checkSingleQuotedVariables "sed 's/${foo}/bar/'"

prop_checkSingleQuotedVariables3b= verify checkSingleQuotedVariables "sed 's/$(echo cow)/bar/'"

prop_checkSingleQuotedVariables3c= verify checkSingleQuotedVariables "sed 's/$((1+foo))/bar/'"

prop_checkSingleQuotedVariables4 = verifyNot checkSingleQuotedVariables "awk '{print $1}'"

prop_checkSingleQuotedVariables5 = verifyNot checkSingleQuotedVariables "trap 'echo $SECONDS' EXIT"

prop_checkSingleQuotedVariables6 = verifyNot checkSingleQuotedVariables "sed -n '$p'"

prop_checkSingleQuotedVariables6a= verify checkSingleQuotedVariables "sed -n '$pattern'"

checkSingleQuotedVariables params t@(T_SingleQuoted id s) =

when (s `matches` re) $

if "sed" == commandName

then unless (s `matches` sedContra) showMessage

else unless isProbablyOk showMessage

where

parents = parentMap params

showMessage = info id 2016 $

"Expressions don't expand in single quotes, use double quotes for that."

commandName = fromMaybe "" $ do

cmd <- getClosestCommand parents t

name <- getCommandBasename cmd

return name

isProbablyOk = commandName `elem` [

"trap"

,"sh"

,"bash"

,"ksh"

,"zsh"

,"ssh"

]

|| "awk" `isSuffixOf` commandName

|| "perl" `isPrefixOf` commandName

re = mkRegex "\\$[{(0-9a-zA-Z_]"

sedContra = mkRegex "\\$[dp]($|[^a-zA-Z])"

checkSingleQuotedVariables _ _ = return ()

prop_checkUnquotedN = verify checkUnquotedN "if [ -n $foo ]; then echo cow; fi"

prop_checkUnquotedN2 = verify checkUnquotedN "[ -n $cow ]"

prop_checkUnquotedN3 = verifyNot checkUnquotedN "[[ -n $foo ]] && echo cow"

checkUnquotedN _ (T_Condition _ SingleBracket (TC_Unary _ SingleBracket "-n" (T_NormalWord id [t]))) | willSplit t =

err id 2070 "Always true because you failed to quote. Use [[ ]] instead."

checkUnquotedN _ _ = return ()

prop_checkNumberComparisons1 = verify checkNumberComparisons "[[ $foo < 3 ]]"

prop_checkNumberComparisons2 = verify checkNumberComparisons "[[ 0 >= $(cmd) ]]"

prop_checkNumberComparisons3 = verifyNot checkNumberComparisons "[[ $foo ]] > 3"

prop_checkNumberComparisons4 = verify checkNumberComparisons "[[ $foo > 2.72 ]]"

prop_checkNumberComparisons5 = verify checkNumberComparisons "[[ $foo -le 2.72 ]]"

prop_checkNumberComparisons6 = verify checkNumberComparisons "[[ 3.14 = $foo ]]"

checkNumberComparisons _ (TC_Binary id typ op lhs rhs) = do

when (op `elem` ["<", ">", "<=", ">=", "\\<", "\\>", "\\<=", "\\>="]) $ do

when (isNum lhs || isNum rhs) $ err id 2071 $ "\"" ++ op ++ "\" is for string comparisons. Use " ++ (eqv op) ++" ."

mapM_ checkDecimals [lhs, rhs]

when (op `elem` ["-lt", "-gt", "-le", "-ge", "-eq", "=", "=="]) $ do

mapM_ checkDecimals [lhs, rhs]

where

checkDecimals hs = when (isFraction hs) $ err (getId hs) 2072 $ decimalError

decimalError = "Decimals are not supported. Either use integers only, or use bc or awk to compare."

isNum t = case deadSimple t of [v] -> all isDigit v

_ -> False

isFraction t = case deadSimple t of [v] -> isJust $ matchRegex floatRegex v

_ -> False

eqv ('\\':s) = eqv s

eqv "<" = "-lt"

eqv ">" = "-gt"

eqv "<=" = "-le"

eqv ">=" = "-ge"

eqv _ = "the numerical equivalent"

floatRegex = mkRegex "^[0-9]+\\.[0-9]+$"

checkNumberComparisons _ _ = return ()

prop_checkSingleBracketOperators1 = verify checkSingleBracketOperators "[ test =~ foo ]"

prop_checkSingleBracketOperators2 = verify checkSingleBracketOperators "[ $foo > $bar ]"

prop_checkSingleBracketOperators3 = verifyNot checkSingleBracketOperators "[[ foo < bar ]]"

prop_checkSingleBracketOperators5 = verify checkSingleBracketOperators "until [ $n <= $z ]; do echo foo; done"

checkSingleBracketOperators _ (TC_Binary id typ op lhs rhs)

| typ == SingleBracket && op `elem` ["<", ">", "<=", ">="] =

err id 2073 $ "Can't use " ++ op ++" in [ ]. Escape it or use [[..]]."

checkSingleBracketOperators _ (TC_Binary id typ op lhs rhs)

| typ == SingleBracket && op == "=~" =

err id 2074 $ "Can't use " ++ op ++" in [ ]. Use [[..]] instead."

checkSingleBracketOperators _ _ = return ()

prop_checkDoubleBracketOperators1 = verify checkDoubleBracketOperators "[[ 3 \\< 4 ]]"

prop_checkDoubleBracketOperators3 = verifyNot checkDoubleBracketOperators "[[ foo < bar ]]"

checkDoubleBracketOperators _ x@(TC_Binary id typ op lhs rhs)

| typ == DoubleBracket && op `elem` ["\\<", "\\>", "\\<=", "\\>="] =

err id 2075 $ "Escaping " ++ op ++" is required in [..], but invalid in [[..]]"

checkDoubleBracketOperators _ _ = return ()

prop_checkConditionalAndOrs1 = verify checkConditionalAndOrs "[ foo && bar ]"

prop_checkConditionalAndOrs2 = verify checkConditionalAndOrs "[[ foo -o bar ]]"

prop_checkConditionalAndOrs3 = verifyNot checkConditionalAndOrs "[[ foo || bar ]]"

checkConditionalAndOrs _ (TC_And id SingleBracket "&&" _ _) =

err id 2107 "You can't use && inside [..]. Use -a instead."

checkConditionalAndOrs _ (TC_And id DoubleBracket "-a" _ _) =

err id 2108 "In [[..]], use && instead of -a."

checkConditionalAndOrs _ (TC_Or id SingleBracket "||" _ _) =

err id 2109 "You can't use || inside [..]. Use -o instead."

checkConditionalAndOrs _ (TC_Or id DoubleBracket "-o" _ _) =

err id 2110 "In [[..]], use || instead of -o."

checkConditionalAndOrs _ _ = return ()

prop_checkQuotedCondRegex1 = verify checkQuotedCondRegex "[[ $foo =~ \"bar\" ]]"

prop_checkQuotedCondRegex2 = verify checkQuotedCondRegex "[[ $foo =~ 'cow' ]]"

prop_checkQuotedCondRegex3 = verifyNot checkQuotedCondRegex "[[ $foo =~ $foo ]]"

checkQuotedCondRegex _ (TC_Binary _ _ "=~" _ rhs) =

case rhs of

T_NormalWord id [T_DoubleQuoted _ _] -> error id

T_NormalWord id [T_SingleQuoted _ _] -> error id

_ -> return ()

where

error id = err id 2076 $ "Don't quote rhs of =~, it'll match literally rather than as a regex."

checkQuotedCondRegex _ _ = return ()

prop_checkGlobbedRegex1 = verify checkGlobbedRegex "[[ $foo =~ *foo* ]]"

prop_checkGlobbedRegex2 = verify checkGlobbedRegex "[[ $foo =~ f* ]]"

prop_checkGlobbedRegex2a = verify checkGlobbedRegex "[[ $foo =~ \\#* ]]"

prop_checkGlobbedRegex3 = verifyNot checkGlobbedRegex "[[ $foo =~ $foo ]]"

prop_checkGlobbedRegex4 = verifyNot checkGlobbedRegex "[[ $foo =~ ^c.* ]]"

checkGlobbedRegex _ (TC_Binary _ DoubleBracket "=~" _ rhs) =

let s = concat $ deadSimple rhs in

if isConfusedGlobRegex s

then warn (getId rhs) 2049 $ "=~ is for regex. Use == for globs."

else return ()

checkGlobbedRegex _ _ = return ()

prop_checkConstantIfs1 = verify checkConstantIfs "[[ foo != bar ]]"

prop_checkConstantIfs2 = verify checkConstantIfs "[[ n -le 4 ]]"

prop_checkConstantIfs3 = verify checkConstantIfs "[[ $n -le 4 && n -ge 2 ]]"

prop_checkConstantIfs4 = verifyNot checkConstantIfs "[[ $n -le 3 ]]"

prop_checkConstantIfs5 = verifyNot checkConstantIfs "[[ $n -le $n ]]"

checkConstantIfs _ (TC_Binary id typ op lhs rhs)

| op `elem` [ "==", "!=", "<=", ">=", "-eq", "-ne", "-lt", "-le", "-gt", "-ge", "=~", ">", "<", "="] = do

when (isJust lLit && isJust rLit) $ warn id 2050 $ "This expression is constant. Did you forget the $ on a variable?"

where

lLit = getLiteralString lhs

rLit = getLiteralString rhs

checkConstantIfs _ _ = return ()

prop_checkNoaryWasBinary = verify checkNoaryWasBinary "[[ a==$foo ]]"

prop_checkNoaryWasBinary2 = verify checkNoaryWasBinary "[ $foo=3 ]"

prop_checkNoaryWasBinary3 = verify checkNoaryWasBinary "[ $foo!=3 ]"

checkNoaryWasBinary _ (TC_Noary _ _ t@(T_NormalWord id l)) | not $ isConstant t = do

let str = concat $ deadSimple t

when ('=' `elem` str) $ err id 2077 $ "You need spaces around the comparison operator."

checkNoaryWasBinary _ _ = return ()

prop_checkConstantNoary = verify checkConstantNoary "[[ '$(foo)' ]]"

prop_checkConstantNoary2 = verify checkConstantNoary "[ \"-f lol\" ]"

prop_checkConstantNoary3 = verify checkConstantNoary "[[ cmd ]]"

prop_checkConstantNoary4 = verify checkConstantNoary "[[ ! cmd ]]"

checkConstantNoary _ (TC_Noary _ _ t@(T_NormalWord id _)) | isConstant t = do

err id 2078 $ "This expression is constant. Did you forget a $ somewhere?"

checkConstantNoary _ _ = return ()

prop_checkBraceExpansionVars = verify checkBraceExpansionVars "echo {1..$n}"

checkBraceExpansionVars _ (T_BraceExpansion id s) | '$' `elem` s =

warn id 2051 $ "Bash doesn't support variables in brace expansions."

checkBraceExpansionVars _ _ = return ()

prop_checkForDecimals = verify checkForDecimals "((3.14*c))"

checkForDecimals _ (TA_Literal id s) | any (== '.') s = do

err id 2079 $ "(( )) doesn't support decimals. Use bc or awk."

checkForDecimals _ _ = return ()

prop_checkDivBeforeMult = verify checkDivBeforeMult "echo $((c/n*100))"

prop_checkDivBeforeMult2 = verifyNot checkDivBeforeMult "echo $((c*100/n))"

checkDivBeforeMult _ (TA_Binary _ "*" (TA_Binary id "/" _ _) _) = do

info id 2017 $ "Increase precision by replacing a/b*c with a*c/b."

checkDivBeforeMult _ _ = return ()

prop_checkArithmeticDeref = verify checkArithmeticDeref "echo $((3+$foo))"

prop_checkArithmeticDeref2 = verify checkArithmeticDeref "cow=14; (( s+= $cow ))"

prop_checkArithmeticDeref3 = verifyNot checkArithmeticDeref "cow=1/40; (( s+= ${cow%%/*} ))"

prop_checkArithmeticDeref4 = verifyNot checkArithmeticDeref "(( ! $? ))"

prop_checkArithmeticDeref5 = verifyNot checkArithmeticDeref "(($1))"

prop_checkArithmeticDeref6 = verifyNot checkArithmeticDeref "(( ${a[$i]} ))"

checkArithmeticDeref _ (TA_Expansion _ (T_DollarBraced id l)) | not . excepting $ bracedString l =

style id 2004 $ "Don't use $ on variables in (( ))."

where

excepting [] = True

excepting s = (any (`elem` "/.:#%?*@[]") s) || (isDigit $ head s)

checkArithmeticDeref _ _ = return ()

prop_checkArithmeticBadOctal1 = verify checkArithmeticBadOctal "(( 0192 ))"

prop_checkArithmeticBadOctal2 = verifyNot checkArithmeticBadOctal "(( 0x192 ))"

prop_checkArithmeticBadOctal3 = verifyNot checkArithmeticBadOctal "(( 1 ^ 0777 ))"

checkArithmeticBadOctal _ (TA_Base id "0" (TA_Literal _ str)) | '9' `elem` str || '8' `elem` str =

err id 2080 $ "Numbers with leading 0 are considered octal."

checkArithmeticBadOctal _ _ = return ()

prop_checkComparisonAgainstGlob = verify checkComparisonAgainstGlob "[[ $cow == $bar ]]"

prop_checkComparisonAgainstGlob2 = verifyNot checkComparisonAgainstGlob "[[ $cow == \"$bar\" ]]"

prop_checkComparisonAgainstGlob3 = verify checkComparisonAgainstGlob "[ $cow = *foo* ]"

prop_checkComparisonAgainstGlob4 = verifyNot checkComparisonAgainstGlob "[ $cow = foo ]"

checkComparisonAgainstGlob _ (TC_Binary _ DoubleBracket op _ (T_NormalWord id [T_DollarBraced _ _])) | op == "=" || op == "==" =

warn id 2053 $ "Quote the rhs of = in [[ ]] to prevent glob interpretation."

checkComparisonAgainstGlob _ (TC_Binary _ SingleBracket op _ word)

| (op == "=" || op == "==") && isGlob word =

err (getId word) 2081 $ "[ .. ] can't match globs. Use [[ .. ]] or grep."

checkComparisonAgainstGlob _ _ = return ()

prop_checkCommarrays1 = verify checkCommarrays "a=(1, 2)"

prop_checkCommarrays2 = verify checkCommarrays "a+=(1,2,3)"

prop_checkCommarrays3 = verifyNot checkCommarrays "cow=(1 \"foo,bar\" 3)"

checkCommarrays _ (T_Array id l) =

if any ("," `isSuffixOf`) (concatMap deadSimple l) || (length $ filter (==',') (concat $ concatMap deadSimple l)) > 1

then warn id 2054 "Use spaces, not commas, to separate array elements."

else return ()

checkCommarrays _ _ = return ()

prop_checkOrNeq1 = verify checkOrNeq "if [[ $lol -ne cow || $lol -ne foo ]]; then echo foo; fi"

prop_checkOrNeq2 = verify checkOrNeq "(( a!=lol || a!=foo ))"

prop_checkOrNeq3 = verify checkOrNeq "[ \"$a\" != lol || \"$a\" != foo ]"

prop_checkOrNeq4 = verifyNot checkOrNeq "[ a != $cow || b != $foo ]"

checkOrNeq _ (TC_Or id typ op (TC_Binary _ _ op1 word1 _) (TC_Binary _ _ op2 word2 _))

| word1 == word2 && (op1 == op2 && (op1 == "-ne" || op1 == "!=")) =

warn id 2055 $ "You probably wanted " ++ (if typ == SingleBracket then "-a" else "&&") ++ " here."

checkOrNeq _ (TA_Binary id "||" (TA_Binary _ "!=" word1 _) (TA_Binary _ "!=" word2 _))

| word1 == word2 =

warn id 2056 "You probably wanted && here."

checkOrNeq _ _ = return ()

prop_checkValidCondOps1 = verify checkValidCondOps "[[ a -xz b ]]"

prop_checkValidCondOps2 = verify checkValidCondOps "[ -M a ]"