{-
    Copyright 2012-2019 Vidar Holen

    This file is part of ShellCheck.
    https://www.shellcheck.net

    ShellCheck is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    ShellCheck is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-}
{-# LANGUAGE DeriveGeneric, DeriveAnyClass, DeriveTraversable, PatternSynonyms #-}
module ShellCheck.AST where

import GHC.Generics (Generic)
import Control.Monad.Identity
import Control.DeepSeq
import Text.Parsec
import qualified ShellCheck.Regex as Re
import Prelude hiding (id)

newtype Id = Id Int deriving (Int -> Id -> ShowS
[Id] -> ShowS
Id -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Id] -> ShowS
$cshowList :: [Id] -> ShowS
show :: Id -> String
$cshow :: Id -> String
showsPrec :: Int -> Id -> ShowS
$cshowsPrec :: Int -> Id -> ShowS
Show, Id -> Id -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Id -> Id -> Bool
$c/= :: Id -> Id -> Bool
== :: Id -> Id -> Bool
$c== :: Id -> Id -> Bool
Eq, Eq Id
Id -> Id -> Bool
Id -> Id -> Ordering
Id -> Id -> Id
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Id -> Id -> Id
$cmin :: Id -> Id -> Id
max :: Id -> Id -> Id
$cmax :: Id -> Id -> Id
>= :: Id -> Id -> Bool
$c>= :: Id -> Id -> Bool
> :: Id -> Id -> Bool
$c> :: Id -> Id -> Bool
<= :: Id -> Id -> Bool
$c<= :: Id -> Id -> Bool
< :: Id -> Id -> Bool
$c< :: Id -> Id -> Bool
compare :: Id -> Id -> Ordering
$ccompare :: Id -> Id -> Ordering
Ord, forall x. Rep Id x -> Id
forall x. Id -> Rep Id x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Id x -> Id
$cfrom :: forall x. Id -> Rep Id x
Generic, Id -> ()
forall a. (a -> ()) -> NFData a
rnf :: Id -> ()
$crnf :: Id -> ()
NFData)

data Quoted = Quoted | Unquoted deriving (Int -> Quoted -> ShowS
[Quoted] -> ShowS
Quoted -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Quoted] -> ShowS
$cshowList :: [Quoted] -> ShowS
show :: Quoted -> String
$cshow :: Quoted -> String
showsPrec :: Int -> Quoted -> ShowS
$cshowsPrec :: Int -> Quoted -> ShowS
Show, Quoted -> Quoted -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Quoted -> Quoted -> Bool
$c/= :: Quoted -> Quoted -> Bool
== :: Quoted -> Quoted -> Bool
$c== :: Quoted -> Quoted -> Bool
Eq)
data Dashed = Dashed | Undashed deriving (Int -> Dashed -> ShowS
[Dashed] -> ShowS
Dashed -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Dashed] -> ShowS
$cshowList :: [Dashed] -> ShowS
show :: Dashed -> String
$cshow :: Dashed -> String
showsPrec :: Int -> Dashed -> ShowS
$cshowsPrec :: Int -> Dashed -> ShowS
Show, Dashed -> Dashed -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Dashed -> Dashed -> Bool
$c/= :: Dashed -> Dashed -> Bool
== :: Dashed -> Dashed -> Bool
$c== :: Dashed -> Dashed -> Bool
Eq)
data AssignmentMode = Assign | Append deriving (Int -> AssignmentMode -> ShowS
[AssignmentMode] -> ShowS
AssignmentMode -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AssignmentMode] -> ShowS
$cshowList :: [AssignmentMode] -> ShowS
show :: AssignmentMode -> String
$cshow :: AssignmentMode -> String
showsPrec :: Int -> AssignmentMode -> ShowS
$cshowsPrec :: Int -> AssignmentMode -> ShowS
Show, AssignmentMode -> AssignmentMode -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AssignmentMode -> AssignmentMode -> Bool
$c/= :: AssignmentMode -> AssignmentMode -> Bool
== :: AssignmentMode -> AssignmentMode -> Bool
$c== :: AssignmentMode -> AssignmentMode -> Bool
Eq)
newtype FunctionKeyword = FunctionKeyword Bool deriving (Int -> FunctionKeyword -> ShowS
[FunctionKeyword] -> ShowS
FunctionKeyword -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FunctionKeyword] -> ShowS
$cshowList :: [FunctionKeyword] -> ShowS
show :: FunctionKeyword -> String
$cshow :: FunctionKeyword -> String
showsPrec :: Int -> FunctionKeyword -> ShowS
$cshowsPrec :: Int -> FunctionKeyword -> ShowS
Show, FunctionKeyword -> FunctionKeyword -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FunctionKeyword -> FunctionKeyword -> Bool
$c/= :: FunctionKeyword -> FunctionKeyword -> Bool
== :: FunctionKeyword -> FunctionKeyword -> Bool
$c== :: FunctionKeyword -> FunctionKeyword -> Bool
Eq)
newtype FunctionParentheses = FunctionParentheses Bool deriving (Int -> FunctionParentheses -> ShowS
[FunctionParentheses] -> ShowS
FunctionParentheses -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FunctionParentheses] -> ShowS
$cshowList :: [FunctionParentheses] -> ShowS
show :: FunctionParentheses -> String
$cshow :: FunctionParentheses -> String
showsPrec :: Int -> FunctionParentheses -> ShowS
$cshowsPrec :: Int -> FunctionParentheses -> ShowS
Show, FunctionParentheses -> FunctionParentheses -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FunctionParentheses -> FunctionParentheses -> Bool
$c/= :: FunctionParentheses -> FunctionParentheses -> Bool
== :: FunctionParentheses -> FunctionParentheses -> Bool
$c== :: FunctionParentheses -> FunctionParentheses -> Bool
Eq)
data CaseType = CaseBreak | CaseFallThrough | CaseContinue deriving (Int -> CaseType -> ShowS
[CaseType] -> ShowS
CaseType -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CaseType] -> ShowS
$cshowList :: [CaseType] -> ShowS
show :: CaseType -> String
$cshow :: CaseType -> String
showsPrec :: Int -> CaseType -> ShowS
$cshowsPrec :: Int -> CaseType -> ShowS
Show, CaseType -> CaseType -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CaseType -> CaseType -> Bool
$c/= :: CaseType -> CaseType -> Bool
== :: CaseType -> CaseType -> Bool
$c== :: CaseType -> CaseType -> Bool
Eq)

newtype Root = Root Token
data Token = OuterToken Id (InnerToken Token) deriving (Int -> Token -> ShowS
[Token] -> ShowS
Token -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Token] -> ShowS
$cshowList :: [Token] -> ShowS
show :: Token -> String
$cshow :: Token -> String
showsPrec :: Int -> Token -> ShowS
$cshowsPrec :: Int -> Token -> ShowS
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_Parenthesis 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
    | 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 String t
    deriving (Int -> InnerToken t -> ShowS
forall t. Show t => Int -> InnerToken t -> ShowS
forall t. Show t => [InnerToken t] -> ShowS
forall t. Show t => InnerToken t -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [InnerToken t] -> ShowS
$cshowList :: forall t. Show t => [InnerToken t] -> ShowS
show :: InnerToken t -> String
$cshow :: forall t. Show t => InnerToken t -> String
showsPrec :: Int -> InnerToken t -> ShowS
$cshowsPrec :: forall t. Show t => Int -> InnerToken t -> ShowS
Show, InnerToken t -> InnerToken t -> Bool
forall t. Eq t => InnerToken t -> InnerToken t -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: InnerToken t -> InnerToken t -> Bool
$c/= :: forall t. Eq t => InnerToken t -> InnerToken t -> Bool
== :: InnerToken t -> InnerToken t -> Bool
$c== :: forall t. Eq t => InnerToken t -> InnerToken t -> Bool
Eq, forall a b. a -> InnerToken b -> InnerToken a
forall a b. (a -> b) -> InnerToken a -> InnerToken b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> InnerToken b -> InnerToken a
$c<$ :: forall a b. a -> InnerToken b -> InnerToken a
fmap :: forall a b. (a -> b) -> InnerToken a -> InnerToken b
$cfmap :: forall a b. (a -> b) -> InnerToken a -> InnerToken b
Functor, forall a. Eq a => a -> InnerToken a -> Bool
forall a. Num a => InnerToken a -> a
forall a. Ord a => InnerToken a -> a
forall m. Monoid m => InnerToken m -> m
forall a. InnerToken a -> Bool
forall a. InnerToken a -> Int
forall a. InnerToken a -> [a]
forall a. (a -> a -> a) -> InnerToken a -> a
forall m a. Monoid m => (a -> m) -> InnerToken a -> m
forall b a. (b -> a -> b) -> b -> InnerToken a -> b
forall a b. (a -> b -> b) -> b -> InnerToken a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => InnerToken a -> a
$cproduct :: forall a. Num a => InnerToken a -> a
sum :: forall a. Num a => InnerToken a -> a
$csum :: forall a. Num a => InnerToken a -> a
minimum :: forall a. Ord a => InnerToken a -> a
$cminimum :: forall a. Ord a => InnerToken a -> a
maximum :: forall a. Ord a => InnerToken a -> a
$cmaximum :: forall a. Ord a => InnerToken a -> a
elem :: forall a. Eq a => a -> InnerToken a -> Bool
$celem :: forall a. Eq a => a -> InnerToken a -> Bool
length :: forall a. InnerToken a -> Int
$clength :: forall a. InnerToken a -> Int
null :: forall a. InnerToken a -> Bool
$cnull :: forall a. InnerToken a -> Bool
toList :: forall a. InnerToken a -> [a]
$ctoList :: forall a. InnerToken a -> [a]
foldl1 :: forall a. (a -> a -> a) -> InnerToken a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> InnerToken a -> a
foldr1 :: forall a. (a -> a -> a) -> InnerToken a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> InnerToken a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> InnerToken a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> InnerToken a -> b
foldl :: forall b a. (b -> a -> b) -> b -> InnerToken a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> InnerToken a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> InnerToken a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> InnerToken a -> b
foldr :: forall a b. (a -> b -> b) -> b -> InnerToken a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> InnerToken a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> InnerToken a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> InnerToken a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> InnerToken a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> InnerToken a -> m
fold :: forall m. Monoid m => InnerToken m -> m
$cfold :: forall m. Monoid m => InnerToken m -> m
Foldable, Functor InnerToken
Foldable InnerToken
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
InnerToken (m a) -> m (InnerToken a)
forall (f :: * -> *) a.
Applicative f =>
InnerToken (f a) -> f (InnerToken a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> InnerToken a -> m (InnerToken b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> InnerToken a -> f (InnerToken b)
sequence :: forall (m :: * -> *) a.
Monad m =>
InnerToken (m a) -> m (InnerToken a)
$csequence :: forall (m :: * -> *) a.
Monad m =>
InnerToken (m a) -> m (InnerToken a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> InnerToken a -> m (InnerToken b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> InnerToken a -> m (InnerToken b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
InnerToken (f a) -> f (InnerToken a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
InnerToken (f a) -> f (InnerToken a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> InnerToken a -> f (InnerToken b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> InnerToken a -> f (InnerToken b)
Traversable)

data Annotation =
    DisableComment Integer Integer -- [from, to)
    | EnableComment String
    | SourceOverride String
    | ShellOverride String
    | SourcePath String
    | ExternalSources Bool
    deriving (Int -> Annotation -> ShowS
[Annotation] -> ShowS
Annotation -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Annotation] -> ShowS
$cshowList :: [Annotation] -> ShowS
show :: Annotation -> String
$cshow :: Annotation -> String
showsPrec :: Int -> Annotation -> ShowS
$cshowsPrec :: Int -> Annotation -> ShowS
Show, Annotation -> Annotation -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Annotation -> Annotation -> Bool
$c/= :: Annotation -> Annotation -> Bool
== :: Annotation -> Annotation -> Bool
$c== :: Annotation -> Annotation -> Bool
Eq)
data ConditionType = DoubleBracket | SingleBracket deriving (Int -> ConditionType -> ShowS
[ConditionType] -> ShowS
ConditionType -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ConditionType] -> ShowS
$cshowList :: [ConditionType] -> ShowS
show :: ConditionType -> String
$cshow :: ConditionType -> String
showsPrec :: Int -> ConditionType -> ShowS
$cshowsPrec :: Int -> ConditionType -> ShowS
Show, ConditionType -> ConditionType -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ConditionType -> ConditionType -> Bool
$c/= :: ConditionType -> ConditionType -> Bool
== :: ConditionType -> ConditionType -> Bool
$c== :: ConditionType -> ConditionType -> Bool
Eq)

pattern $bT_AND_IF :: Id -> Token
$mT_AND_IF :: forall {r}. Token -> (Id -> r) -> ((# #) -> r) -> r
T_AND_IF id = OuterToken id Inner_T_AND_IF
pattern $bT_Bang :: Id -> Token
$mT_Bang :: forall {r}. Token -> (Id -> r) -> ((# #) -> r) -> r
T_Bang id = OuterToken id Inner_T_Bang
pattern $bT_Case :: Id -> Token
$mT_Case :: forall {r}. Token -> (Id -> r) -> ((# #) -> r) -> r
T_Case id = OuterToken id Inner_T_Case
pattern $bTC_Empty :: Id -> ConditionType -> Token
$mTC_Empty :: forall {r}.
Token -> (Id -> ConditionType -> r) -> ((# #) -> r) -> r
TC_Empty id typ = OuterToken id (Inner_TC_Empty typ)
pattern $bT_CLOBBER :: Id -> Token
$mT_CLOBBER :: forall {r}. Token -> (Id -> r) -> ((# #) -> r) -> r
T_CLOBBER id = OuterToken id Inner_T_CLOBBER
pattern $bT_DGREAT :: Id -> Token
$mT_DGREAT :: forall {r}. Token -> (Id -> r) -> ((# #) -> r) -> r
T_DGREAT id = OuterToken id Inner_T_DGREAT
pattern $bT_DLESS :: Id -> Token
$mT_DLESS :: forall {r}. Token -> (Id -> r) -> ((# #) -> r) -> r
T_DLESS id = OuterToken id Inner_T_DLESS
pattern $bT_DLESSDASH :: Id -> Token
$mT_DLESSDASH :: forall {r}. Token -> (Id -> r) -> ((# #) -> r) -> r
T_DLESSDASH id = OuterToken id Inner_T_DLESSDASH
pattern $bT_Do :: Id -> Token
$mT_Do :: forall {r}. Token -> (Id -> r) -> ((# #) -> r) -> r
T_Do id = OuterToken id Inner_T_Do
pattern $bT_DollarSingleQuoted :: Id -> String -> Token
$mT_DollarSingleQuoted :: forall {r}. Token -> (Id -> String -> r) -> ((# #) -> r) -> r
T_DollarSingleQuoted id str = OuterToken id (Inner_T_DollarSingleQuoted str)
pattern $bT_Done :: Id -> Token
$mT_Done :: forall {r}. Token -> (Id -> r) -> ((# #) -> r) -> r
T_Done id = OuterToken id Inner_T_Done
pattern $bT_DSEMI :: Id -> Token
$mT_DSEMI :: forall {r}. Token -> (Id -> r) -> ((# #) -> r) -> r
T_DSEMI id = OuterToken id Inner_T_DSEMI
pattern $bT_Elif :: Id -> Token
$mT_Elif :: forall {r}. Token -> (Id -> r) -> ((# #) -> r) -> r
T_Elif id = OuterToken id Inner_T_Elif
pattern $bT_Else :: Id -> Token
$mT_Else :: forall {r}. Token -> (Id -> r) -> ((# #) -> r) -> r
T_Else id = OuterToken id Inner_T_Else
pattern $bT_EOF :: Id -> Token
$mT_EOF :: forall {r}. Token -> (Id -> r) -> ((# #) -> r) -> r
T_EOF id = OuterToken id Inner_T_EOF
pattern $bT_Esac :: Id -> Token
$mT_Esac :: forall {r}. Token -> (Id -> r) -> ((# #) -> r) -> r
T_Esac id = OuterToken id Inner_T_Esac
pattern $bT_Fi :: Id -> Token
$mT_Fi :: forall {r}. Token -> (Id -> r) -> ((# #) -> r) -> r
T_Fi id = OuterToken id Inner_T_Fi
pattern $bT_For :: Id -> Token
$mT_For :: forall {r}. Token -> (Id -> r) -> ((# #) -> r) -> r
T_For id = OuterToken id Inner_T_For
pattern $bT_Glob :: Id -> String -> Token
$mT_Glob :: forall {r}. Token -> (Id -> String -> r) -> ((# #) -> r) -> r
T_Glob id str = OuterToken id (Inner_T_Glob str)
pattern $bT_GREATAND :: Id -> Token
$mT_GREATAND :: forall {r}. Token -> (Id -> r) -> ((# #) -> r) -> r
T_GREATAND id = OuterToken id Inner_T_GREATAND
pattern $bT_Greater :: Id -> Token
$mT_Greater :: forall {r}. Token -> (Id -> r) -> ((# #) -> r) -> r
T_Greater id = OuterToken id Inner_T_Greater
pattern $bT_If :: Id -> Token
$mT_If :: forall {r}. Token -> (Id -> r) -> ((# #) -> r) -> r
T_If id = OuterToken id Inner_T_If
pattern $bT_In :: Id -> Token
$mT_In :: forall {r}. Token -> (Id -> r) -> ((# #) -> r) -> r
T_In id = OuterToken id Inner_T_In
pattern $bT_Lbrace :: Id -> Token
$mT_Lbrace :: forall {r}. Token -> (Id -> r) -> ((# #) -> r) -> r
T_Lbrace id = OuterToken id Inner_T_Lbrace
pattern $bT_Less :: Id -> Token
$mT_Less :: forall {r}. Token -> (Id -> r) -> ((# #) -> r) -> r
T_Less id = OuterToken id Inner_T_Less
pattern $bT_LESSAND :: Id -> Token
$mT_LESSAND :: forall {r}. Token -> (Id -> r) -> ((# #) -> r) -> r
T_LESSAND id = OuterToken id Inner_T_LESSAND
pattern $bT_LESSGREAT :: Id -> Token
$mT_LESSGREAT :: forall {r}. Token -> (Id -> r) -> ((# #) -> r) -> r
T_LESSGREAT id = OuterToken id Inner_T_LESSGREAT
pattern $bT_Literal :: Id -> String -> Token
$mT_Literal :: forall {r}. Token -> (Id -> String -> r) -> ((# #) -> r) -> r
T_Literal id str = OuterToken id (Inner_T_Literal str)
pattern $bT_Lparen :: Id -> Token
$mT_Lparen :: forall {r}. Token -> (Id -> r) -> ((# #) -> r) -> r
T_Lparen id = OuterToken id Inner_T_Lparen
pattern $bT_NEWLINE :: Id -> Token
$mT_NEWLINE :: forall {r}. Token -> (Id -> r) -> ((# #) -> r) -> r
T_NEWLINE id = OuterToken id Inner_T_NEWLINE
pattern $bT_OR_IF :: Id -> Token
$mT_OR_IF :: forall {r}. Token -> (Id -> r) -> ((# #) -> r) -> r
T_OR_IF id = OuterToken id Inner_T_OR_IF
pattern $bT_ParamSubSpecialChar :: Id -> String -> Token
$mT_ParamSubSpecialChar :: forall {r}. Token -> (Id -> String -> r) -> ((# #) -> r) -> r
T_ParamSubSpecialChar id str = OuterToken id (Inner_T_ParamSubSpecialChar str)
pattern $bT_Pipe :: Id -> String -> Token
$mT_Pipe :: forall {r}. Token -> (Id -> String -> r) -> ((# #) -> r) -> r
T_Pipe id str = OuterToken id (Inner_T_Pipe str)
pattern $bT_Rbrace :: Id -> Token
$mT_Rbrace :: forall {r}. Token -> (Id -> r) -> ((# #) -> r) -> r
T_Rbrace id = OuterToken id Inner_T_Rbrace
pattern $bT_Rparen :: Id -> Token
$mT_Rparen :: forall {r}. Token -> (Id -> r) -> ((# #) -> r) -> r
T_Rparen id = OuterToken id Inner_T_Rparen
pattern $bT_Select :: Id -> Token
$mT_Select :: forall {r}. Token -> (Id -> r) -> ((# #) -> r) -> r
T_Select id = OuterToken id Inner_T_Select
pattern $bT_Semi :: Id -> Token
$mT_Semi :: forall {r}. Token -> (Id -> r) -> ((# #) -> r) -> r
T_Semi id = OuterToken id Inner_T_Semi
pattern $bT_SingleQuoted :: Id -> String -> Token
$mT_SingleQuoted :: forall {r}. Token -> (Id -> String -> r) -> ((# #) -> r) -> r
T_SingleQuoted id str = OuterToken id (Inner_T_SingleQuoted str)
pattern $bT_Then :: Id -> Token
$mT_Then :: forall {r}. Token -> (Id -> r) -> ((# #) -> r) -> r
T_Then id = OuterToken id Inner_T_Then
pattern $bT_UnparsedIndex :: Id -> SourcePos -> String -> Token
$mT_UnparsedIndex :: forall {r}.
Token -> (Id -> SourcePos -> String -> r) -> ((# #) -> r) -> r
T_UnparsedIndex id pos str = OuterToken id (Inner_T_UnparsedIndex pos str)
pattern $bT_Until :: Id -> Token
$mT_Until :: forall {r}. Token -> (Id -> r) -> ((# #) -> r) -> r
T_Until id = OuterToken id Inner_T_Until
pattern $bT_While :: Id -> Token
$mT_While :: forall {r}. Token -> (Id -> r) -> ((# #) -> r) -> r
T_While id = OuterToken id Inner_T_While
pattern $bTA_Assignment :: Id -> String -> Token -> Token -> Token
$mTA_Assignment :: forall {r}.
Token -> (Id -> String -> Token -> Token -> r) -> ((# #) -> r) -> r
TA_Assignment id op t1 t2 = OuterToken id (Inner_TA_Assignment op t1 t2)
pattern $bTA_Binary :: Id -> String -> Token -> Token -> Token
$mTA_Binary :: forall {r}.
Token -> (Id -> String -> Token -> Token -> r) -> ((# #) -> r) -> r
TA_Binary id op t1 t2 = OuterToken id (Inner_TA_Binary op t1 t2)
pattern $bTA_Expansion :: Id -> [Token] -> Token
$mTA_Expansion :: forall {r}. Token -> (Id -> [Token] -> r) -> ((# #) -> r) -> r
TA_Expansion id t = OuterToken id (Inner_TA_Expansion t)
pattern $bT_AndIf :: Id -> Token -> Token -> Token
$mT_AndIf :: forall {r}.
Token -> (Id -> Token -> Token -> r) -> ((# #) -> r) -> r
T_AndIf id t u = OuterToken id (Inner_T_AndIf t u)
pattern $bT_Annotation :: Id -> [Annotation] -> Token -> Token
$mT_Annotation :: forall {r}.
Token -> (Id -> [Annotation] -> Token -> r) -> ((# #) -> r) -> r
T_Annotation id anns t = OuterToken id (Inner_T_Annotation anns t)
pattern $bT_Arithmetic :: Id -> Token -> Token
$mT_Arithmetic :: forall {r}. Token -> (Id -> Token -> r) -> ((# #) -> r) -> r
T_Arithmetic id c = OuterToken id (Inner_T_Arithmetic c)
pattern $bT_Array :: Id -> [Token] -> Token
$mT_Array :: forall {r}. Token -> (Id -> [Token] -> r) -> ((# #) -> r) -> r
T_Array id t = OuterToken id (Inner_T_Array t)
pattern $bTA_Sequence :: Id -> [Token] -> Token
$mTA_Sequence :: forall {r}. Token -> (Id -> [Token] -> r) -> ((# #) -> r) -> r
TA_Sequence id l = OuterToken id (Inner_TA_Sequence l)
pattern $bTA_Parentesis :: Id -> Token -> Token
$mTA_Parentesis :: forall {r}. Token -> (Id -> Token -> r) -> ((# #) -> r) -> r
TA_Parentesis id t = OuterToken id (Inner_TA_Parenthesis t)
pattern $bT_Assignment :: Id -> AssignmentMode -> String -> [Token] -> Token -> Token
$mT_Assignment :: forall {r}.
Token
-> (Id -> AssignmentMode -> String -> [Token] -> Token -> r)
-> ((# #) -> r)
-> r
T_Assignment id mode var indices value = OuterToken id (Inner_T_Assignment mode var indices value)
pattern $bTA_Trinary :: Id -> Token -> Token -> Token -> Token
$mTA_Trinary :: forall {r}.
Token -> (Id -> Token -> Token -> Token -> r) -> ((# #) -> r) -> r
TA_Trinary id t1 t2 t3 = OuterToken id (Inner_TA_Trinary t1 t2 t3)
pattern $bTA_Unary :: Id -> String -> Token -> Token
$mTA_Unary :: forall {r}.
Token -> (Id -> String -> Token -> r) -> ((# #) -> r) -> r
TA_Unary id op t1 = OuterToken id (Inner_TA_Unary op t1)
pattern $bTA_Variable :: Id -> String -> [Token] -> Token
$mTA_Variable :: forall {r}.
Token -> (Id -> String -> [Token] -> r) -> ((# #) -> r) -> r
TA_Variable id str t = OuterToken id (Inner_TA_Variable str t)
pattern $bT_Backgrounded :: Id -> Token -> Token
$mT_Backgrounded :: forall {r}. Token -> (Id -> Token -> r) -> ((# #) -> r) -> r
T_Backgrounded id l = OuterToken id (Inner_T_Backgrounded l)
pattern $bT_Backticked :: Id -> [Token] -> Token
$mT_Backticked :: forall {r}. Token -> (Id -> [Token] -> r) -> ((# #) -> r) -> r
T_Backticked id list = OuterToken id (Inner_T_Backticked list)
pattern $bT_Banged :: Id -> Token -> Token
$mT_Banged :: forall {r}. Token -> (Id -> Token -> r) -> ((# #) -> r) -> r
T_Banged id l = OuterToken id (Inner_T_Banged l)
pattern $bT_BatsTest :: Id -> String -> Token -> Token
$mT_BatsTest :: forall {r}.
Token -> (Id -> String -> Token -> r) -> ((# #) -> r) -> r
T_BatsTest id name t = OuterToken id (Inner_T_BatsTest name t)
pattern $bT_BraceExpansion :: Id -> [Token] -> Token
$mT_BraceExpansion :: forall {r}. Token -> (Id -> [Token] -> r) -> ((# #) -> r) -> r
T_BraceExpansion id list = OuterToken id (Inner_T_BraceExpansion list)
pattern $bT_BraceGroup :: Id -> [Token] -> Token
$mT_BraceGroup :: forall {r}. Token -> (Id -> [Token] -> r) -> ((# #) -> r) -> r
T_BraceGroup id l = OuterToken id (Inner_T_BraceGroup l)
pattern $bTC_And :: Id -> ConditionType -> String -> Token -> Token -> Token
$mTC_And :: forall {r}.
Token
-> (Id -> ConditionType -> String -> Token -> Token -> r)
-> ((# #) -> r)
-> r
TC_And id typ str t1 t2 = OuterToken id (Inner_TC_And typ str t1 t2)
pattern $bT_CaseExpression :: Id -> Token -> [(CaseType, [Token], [Token])] -> Token
$mT_CaseExpression :: forall {r}.
Token
-> (Id -> Token -> [(CaseType, [Token], [Token])] -> r)
-> ((# #) -> r)
-> r
T_CaseExpression id word cases = OuterToken id (Inner_T_CaseExpression word cases)
pattern $bTC_Binary :: Id -> ConditionType -> String -> Token -> Token -> Token
$mTC_Binary :: forall {r}.
Token
-> (Id -> ConditionType -> String -> Token -> Token -> r)
-> ((# #) -> r)
-> r
TC_Binary id typ op lhs rhs = OuterToken id (Inner_TC_Binary typ op lhs rhs)
pattern $bTC_Group :: Id -> ConditionType -> Token -> Token
$mTC_Group :: forall {r}.
Token -> (Id -> ConditionType -> Token -> r) -> ((# #) -> r) -> r
TC_Group id typ token = OuterToken id (Inner_TC_Group typ token)
pattern $bTC_Nullary :: Id -> ConditionType -> Token -> Token
$mTC_Nullary :: forall {r}.
Token -> (Id -> ConditionType -> Token -> r) -> ((# #) -> r) -> r
TC_Nullary id typ token = OuterToken id (Inner_TC_Nullary typ token)
pattern $bT_Condition :: Id -> ConditionType -> Token -> Token
$mT_Condition :: forall {r}.
Token -> (Id -> ConditionType -> Token -> r) -> ((# #) -> r) -> r
T_Condition id typ token = OuterToken id (Inner_T_Condition typ token)
pattern $bT_CoProcBody :: Id -> Token -> Token
$mT_CoProcBody :: forall {r}. Token -> (Id -> Token -> r) -> ((# #) -> r) -> r
T_CoProcBody id t = OuterToken id (Inner_T_CoProcBody t)
pattern $bT_CoProc :: Id -> Maybe String -> Token -> Token
$mT_CoProc :: forall {r}.
Token -> (Id -> Maybe String -> Token -> r) -> ((# #) -> r) -> r
T_CoProc id var body = OuterToken id (Inner_T_CoProc var body)
pattern $bTC_Or :: Id -> ConditionType -> String -> Token -> Token -> Token
$mTC_Or :: forall {r}.
Token
-> (Id -> ConditionType -> String -> Token -> Token -> r)
-> ((# #) -> r)
-> r
TC_Or id typ str t1 t2 = OuterToken id (Inner_TC_Or typ str t1 t2)
pattern $bTC_Unary :: Id -> ConditionType -> String -> Token -> Token
$mTC_Unary :: forall {r}.
Token
-> (Id -> ConditionType -> String -> Token -> r)
-> ((# #) -> r)
-> r
TC_Unary id typ op token = OuterToken id (Inner_TC_Unary typ op token)
pattern $bT_DollarArithmetic :: Id -> Token -> Token
$mT_DollarArithmetic :: forall {r}. Token -> (Id -> Token -> r) -> ((# #) -> r) -> r
T_DollarArithmetic id c = OuterToken id (Inner_T_DollarArithmetic c)
pattern $bT_DollarBraceCommandExpansion :: Id -> [Token] -> Token
$mT_DollarBraceCommandExpansion :: forall {r}. Token -> (Id -> [Token] -> r) -> ((# #) -> r) -> r
T_DollarBraceCommandExpansion id list = OuterToken id (Inner_T_DollarBraceCommandExpansion list)
pattern $bT_DollarBraced :: Id -> Bool -> Token -> Token
$mT_DollarBraced :: forall {r}.
Token -> (Id -> Bool -> Token -> r) -> ((# #) -> r) -> r
T_DollarBraced id braced op = OuterToken id (Inner_T_DollarBraced braced op)
pattern $bT_DollarBracket :: Id -> Token -> Token
$mT_DollarBracket :: forall {r}. Token -> (Id -> Token -> r) -> ((# #) -> r) -> r
T_DollarBracket id c = OuterToken id (Inner_T_DollarBracket c)
pattern $bT_DollarDoubleQuoted :: Id -> [Token] -> Token
$mT_DollarDoubleQuoted :: forall {r}. Token -> (Id -> [Token] -> r) -> ((# #) -> r) -> r
T_DollarDoubleQuoted id list = OuterToken id (Inner_T_DollarDoubleQuoted list)
pattern $bT_DollarExpansion :: Id -> [Token] -> Token
$mT_DollarExpansion :: forall {r}. Token -> (Id -> [Token] -> r) -> ((# #) -> r) -> r
T_DollarExpansion id list = OuterToken id (Inner_T_DollarExpansion list)
pattern $bT_DoubleQuoted :: Id -> [Token] -> Token
$mT_DoubleQuoted :: forall {r}. Token -> (Id -> [Token] -> r) -> ((# #) -> r) -> r
T_DoubleQuoted id list = OuterToken id (Inner_T_DoubleQuoted list)
pattern $bT_Extglob :: Id -> String -> [Token] -> Token
$mT_Extglob :: forall {r}.
Token -> (Id -> String -> [Token] -> r) -> ((# #) -> r) -> r
T_Extglob id str l = OuterToken id (Inner_T_Extglob str l)
pattern $bT_FdRedirect :: Id -> String -> Token -> Token
$mT_FdRedirect :: forall {r}.
Token -> (Id -> String -> Token -> r) -> ((# #) -> r) -> r
T_FdRedirect id v t = OuterToken id (Inner_T_FdRedirect v t)
pattern $bT_ForArithmetic :: Id -> Token -> Token -> Token -> [Token] -> Token
$mT_ForArithmetic :: forall {r}.
Token
-> (Id -> Token -> Token -> Token -> [Token] -> r)
-> ((# #) -> r)
-> r
T_ForArithmetic id a b c group = OuterToken id (Inner_T_ForArithmetic a b c group)
pattern $bT_ForIn :: Id -> String -> [Token] -> [Token] -> Token
$mT_ForIn :: forall {r}.
Token
-> (Id -> String -> [Token] -> [Token] -> r) -> ((# #) -> r) -> r
T_ForIn id v w l = OuterToken id (Inner_T_ForIn v w l)
pattern $bT_Function :: Id
-> FunctionKeyword
-> FunctionParentheses
-> String
-> Token
-> Token
$mT_Function :: forall {r}.
Token
-> (Id
    -> FunctionKeyword -> FunctionParentheses -> String -> Token -> r)
-> ((# #) -> r)
-> r
T_Function id a b name body = OuterToken id (Inner_T_Function a b name body)
pattern $bT_HereDoc :: Id -> Dashed -> Quoted -> String -> [Token] -> Token
$mT_HereDoc :: forall {r}.
Token
-> (Id -> Dashed -> Quoted -> String -> [Token] -> r)
-> ((# #) -> r)
-> r
T_HereDoc id d q str l = OuterToken id (Inner_T_HereDoc d q str l)
pattern $bT_HereString :: Id -> Token -> Token
$mT_HereString :: forall {r}. Token -> (Id -> Token -> r) -> ((# #) -> r) -> r
T_HereString id word = OuterToken id (Inner_T_HereString word)
pattern $bT_IfExpression :: Id -> [([Token], [Token])] -> [Token] -> Token
$mT_IfExpression :: forall {r}.
Token
-> (Id -> [([Token], [Token])] -> [Token] -> r)
-> ((# #) -> r)
-> r
T_IfExpression id conditions elses = OuterToken id (Inner_T_IfExpression conditions elses)
pattern $bT_Include :: Id -> Token -> Token
$mT_Include :: forall {r}. Token -> (Id -> Token -> r) -> ((# #) -> r) -> r
T_Include id script = OuterToken id (Inner_T_Include script)
pattern $bT_IndexedElement :: Id -> [Token] -> Token -> Token
$mT_IndexedElement :: forall {r}.
Token -> (Id -> [Token] -> Token -> r) -> ((# #) -> r) -> r
T_IndexedElement id indices t = OuterToken id (Inner_T_IndexedElement indices t)
pattern $bT_IoDuplicate :: Id -> Token -> String -> Token
$mT_IoDuplicate :: forall {r}.
Token -> (Id -> Token -> String -> r) -> ((# #) -> r) -> r
T_IoDuplicate id op num = OuterToken id (Inner_T_IoDuplicate op num)
pattern $bT_IoFile :: Id -> Token -> Token -> Token
$mT_IoFile :: forall {r}.
Token -> (Id -> Token -> Token -> r) -> ((# #) -> r) -> r
T_IoFile id op file = OuterToken id (Inner_T_IoFile op file)
pattern $bT_NormalWord :: Id -> [Token] -> Token
$mT_NormalWord :: forall {r}. Token -> (Id -> [Token] -> r) -> ((# #) -> r) -> r
T_NormalWord id list = OuterToken id (Inner_T_NormalWord list)
pattern $bT_OrIf :: Id -> Token -> Token -> Token
$mT_OrIf :: forall {r}.
Token -> (Id -> Token -> Token -> r) -> ((# #) -> r) -> r
T_OrIf id t u = OuterToken id (Inner_T_OrIf t u)
pattern $bT_Pipeline :: Id -> [Token] -> [Token] -> Token
$mT_Pipeline :: forall {r}.
Token -> (Id -> [Token] -> [Token] -> r) -> ((# #) -> r) -> r
T_Pipeline id l1 l2 = OuterToken id (Inner_T_Pipeline l1 l2)
pattern $bT_ProcSub :: Id -> String -> [Token] -> Token
$mT_ProcSub :: forall {r}.
Token -> (Id -> String -> [Token] -> r) -> ((# #) -> r) -> r
T_ProcSub id typ l = OuterToken id (Inner_T_ProcSub typ l)
pattern $bT_Redirecting :: Id -> [Token] -> Token -> Token
$mT_Redirecting :: forall {r}.
Token -> (Id -> [Token] -> Token -> r) -> ((# #) -> r) -> r
T_Redirecting id redirs cmd = OuterToken id (Inner_T_Redirecting redirs cmd)
pattern $bT_Script :: Id -> Token -> [Token] -> Token
$mT_Script :: forall {r}.
Token -> (Id -> Token -> [Token] -> r) -> ((# #) -> r) -> r
T_Script id shebang list = OuterToken id (Inner_T_Script shebang list)
pattern $bT_SelectIn :: Id -> String -> [Token] -> [Token] -> Token
$mT_SelectIn :: forall {r}.
Token
-> (Id -> String -> [Token] -> [Token] -> r) -> ((# #) -> r) -> r
T_SelectIn id v w l = OuterToken id (Inner_T_SelectIn v w l)
pattern $bT_SimpleCommand :: Id -> [Token] -> [Token] -> Token
$mT_SimpleCommand :: forall {r}.
Token -> (Id -> [Token] -> [Token] -> r) -> ((# #) -> r) -> r
T_SimpleCommand id vars cmds = OuterToken id (Inner_T_SimpleCommand vars cmds)
pattern $bT_SourceCommand :: Id -> Token -> Token -> Token
$mT_SourceCommand :: forall {r}.
Token -> (Id -> Token -> Token -> r) -> ((# #) -> r) -> r
T_SourceCommand id includer t_include = OuterToken id (Inner_T_SourceCommand includer t_include)
pattern $bT_Subshell :: Id -> [Token] -> Token
$mT_Subshell :: forall {r}. Token -> (Id -> [Token] -> r) -> ((# #) -> r) -> r
T_Subshell id l = OuterToken id (Inner_T_Subshell l)
pattern $bT_UntilExpression :: Id -> [Token] -> [Token] -> Token
$mT_UntilExpression :: forall {r}.
Token -> (Id -> [Token] -> [Token] -> r) -> ((# #) -> r) -> r
T_UntilExpression id c l = OuterToken id (Inner_T_UntilExpression c l)
pattern $bT_WhileExpression :: Id -> [Token] -> [Token] -> Token
$mT_WhileExpression :: forall {r}.
Token -> (Id -> [Token] -> [Token] -> r) -> ((# #) -> r) -> r
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, TA_Parentesis, 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
    OuterToken Id
_ InnerToken Token
a == :: Token -> Token -> Bool
== OuterToken Id
_ InnerToken Token
b = InnerToken Token
a forall a. Eq a => a -> a -> Bool
== InnerToken Token
b

analyze :: Monad m => (Token -> m ()) -> (Token -> m ()) -> (Token -> m Token) -> Token -> m Token
analyze :: forall (m :: * -> *).
Monad m =>
(Token -> m ())
-> (Token -> m ()) -> (Token -> m Token) -> Token -> m Token
analyze Token -> m ()
f Token -> m ()
g Token -> m Token
i =
    Token -> m Token
round
  where
    round :: Token -> m Token
round t :: Token
t@(OuterToken Id
id InnerToken Token
it) = do
        Token -> m ()
f Token
t
        InnerToken Token
newIt <- forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse Token -> m Token
round InnerToken Token
it
        Token -> m ()
g Token
t
        Token -> m Token
i (Id -> InnerToken Token -> Token
OuterToken Id
id InnerToken Token
newIt)

getId :: Token -> Id
getId :: Token -> Id
getId (OuterToken Id
id InnerToken Token
_) = Id
id

blank :: Monad m => Token -> m ()
blank :: forall (m :: * -> *). Monad m => Token -> m ()
blank = forall a b. a -> b -> a
const forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a. Monad m => a -> m a
return ()
doAnalysis :: Monad m => (Token -> m ()) -> Token -> m Token
doAnalysis :: forall (m :: * -> *).
Monad m =>
(Token -> m ()) -> Token -> m Token
doAnalysis Token -> m ()
f = forall (m :: * -> *).
Monad m =>
(Token -> m ())
-> (Token -> m ()) -> (Token -> m Token) -> Token -> m Token
analyze Token -> m ()
f forall (m :: * -> *). Monad m => Token -> m ()
blank forall (m :: * -> *) a. Monad m => a -> m a
return
doStackAnalysis :: Monad m => (Token -> m ()) -> (Token -> m ()) -> Token -> m Token
doStackAnalysis :: forall (m :: * -> *).
Monad m =>
(Token -> m ()) -> (Token -> m ()) -> Token -> m Token
doStackAnalysis Token -> m ()
startToken Token -> m ()
endToken = forall (m :: * -> *).
Monad m =>
(Token -> m ())
-> (Token -> m ()) -> (Token -> m Token) -> Token -> m Token
analyze Token -> m ()
startToken Token -> m ()
endToken forall (m :: * -> *) a. Monad m => a -> m a
return
doTransform :: (Token -> Token) -> Token -> Token
doTransform :: (Token -> Token) -> Token -> Token
doTransform Token -> Token
i = forall a. Identity a -> a
runIdentity forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *).
Monad m =>
(Token -> m ())
-> (Token -> m ()) -> (Token -> m Token) -> Token -> m Token
analyze forall (m :: * -> *). Monad m => Token -> m ()
blank forall (m :: * -> *). Monad m => Token -> m ()
blank (forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. Token -> Token
i)