{-# LANGUAGE Rank2Types, GADTs #-}
{-# LANGUAGE ScopedTypeVariables #-}

module SemHsTokens where
{-# LINE 2 "src-ag/HsToken.ag" #-}

import CommonTypes
import UU.Scanner.Position(Pos)
{-# LINE 10 "src-generated/SemHsTokens.hs" #-}

{-# LINE 4 "src-ag/SemHsTokens.ag" #-}

import qualified Data.Sequence as Seq
import Data.Sequence(Seq,empty,singleton,(><))
import Data.Foldable(toList)
import Pretty

import TokenDef
import HsToken
import ErrorMessages
{-# LINE 22 "src-generated/SemHsTokens.hs" #-}
import Control.Monad.Identity (Identity)
import qualified Control.Monad.Identity
{-# LINE 58 "src-ag/SemHsTokens.ag" #-}

isNTname allnts (Just (NT nt _ _)) = nt `elem` allnts
isNTname allnts _                  = False
{-# LINE 29 "src-generated/SemHsTokens.hs" #-}
-- HsToken -----------------------------------------------------
-- wrapper
data Inh_HsToken  = Inh_HsToken { Inh_HsToken -> [(Identifier, Type, ChildKind)]
allfields_Inh_HsToken :: ([(Identifier,Type,ChildKind)]), Inh_HsToken -> [Identifier]
allnts_Inh_HsToken :: ([Identifier]), Inh_HsToken -> [(Identifier, Identifier)]
attrs_Inh_HsToken :: ([(Identifier,Identifier)]), Inh_HsToken -> Identifier
con_Inh_HsToken :: (Identifier), Inh_HsToken -> [Identifier]
fieldnames_Inh_HsToken :: ([Identifier]), Inh_HsToken -> Identifier
nt_Inh_HsToken :: (Identifier), Inh_HsToken -> Options
options_Inh_HsToken :: (Options) }
data Syn_HsToken  = Syn_HsToken { Syn_HsToken -> Seq Error
errors_Syn_HsToken :: (Seq Error), Syn_HsToken -> HsToken
output_Syn_HsToken :: (HsToken), Syn_HsToken -> (Pos, String)
tok_Syn_HsToken :: ((Pos,String)), Syn_HsToken -> [(Identifier, Identifier)]
usedAttrs_Syn_HsToken :: ([(Identifier,Identifier)]), Syn_HsToken -> Seq Identifier
usedFields_Syn_HsToken :: (Seq Identifier), Syn_HsToken -> [Identifier]
usedLocals_Syn_HsToken :: ([Identifier]) }
{-# INLINABLE wrap_HsToken #-}
wrap_HsToken :: T_HsToken  -> Inh_HsToken  -> (Syn_HsToken )
wrap_HsToken :: T_HsToken -> Inh_HsToken -> Syn_HsToken
wrap_HsToken (T_HsToken Identity T_HsToken_s2
act) (Inh_HsToken [(Identifier, Type, ChildKind)]
_lhsIallfields [Identifier]
_lhsIallnts [(Identifier, Identifier)]
_lhsIattrs Identifier
_lhsIcon [Identifier]
_lhsIfieldnames Identifier
_lhsInt Options
_lhsIoptions) =
   forall a. Identity a -> a
Control.Monad.Identity.runIdentity (
     do T_HsToken_s2
sem <- Identity T_HsToken_s2
act
        let arg1 :: T_HsToken_vIn1
arg1 = [(Identifier, Type, ChildKind)]
-> [Identifier]
-> [(Identifier, Identifier)]
-> Identifier
-> [Identifier]
-> Identifier
-> Options
-> T_HsToken_vIn1
T_HsToken_vIn1 [(Identifier, Type, ChildKind)]
_lhsIallfields [Identifier]
_lhsIallnts [(Identifier, Identifier)]
_lhsIattrs Identifier
_lhsIcon [Identifier]
_lhsIfieldnames Identifier
_lhsInt Options
_lhsIoptions
        (T_HsToken_vOut1 Seq Error
_lhsOerrors HsToken
_lhsOoutput (Pos, String)
_lhsOtok [(Identifier, Identifier)]
_lhsOusedAttrs Seq Identifier
_lhsOusedFields [Identifier]
_lhsOusedLocals) <- forall (m :: * -> *) a. Monad m => a -> m a
return (T_HsToken_s2 -> T_HsToken_v1
inv_HsToken_s2 T_HsToken_s2
sem T_HsToken_vIn1
arg1)
        forall (m :: * -> *) a. Monad m => a -> m a
return (Seq Error
-> HsToken
-> (Pos, String)
-> [(Identifier, Identifier)]
-> Seq Identifier
-> [Identifier]
-> Syn_HsToken
Syn_HsToken Seq Error
_lhsOerrors HsToken
_lhsOoutput (Pos, String)
_lhsOtok [(Identifier, Identifier)]
_lhsOusedAttrs Seq Identifier
_lhsOusedFields [Identifier]
_lhsOusedLocals)
   )

-- cata
{-# NOINLINE sem_HsToken #-}
sem_HsToken :: HsToken  -> T_HsToken 
sem_HsToken :: HsToken -> T_HsToken
sem_HsToken ( AGLocal Identifier
var_ Pos
pos_ Maybe String
rdesc_ ) = Identifier -> Pos -> Maybe String -> T_HsToken
sem_HsToken_AGLocal Identifier
var_ Pos
pos_ Maybe String
rdesc_
sem_HsToken ( AGField Identifier
field_ Identifier
attr_ Pos
pos_ Maybe String
rdesc_ ) = Identifier -> Identifier -> Pos -> Maybe String -> T_HsToken
sem_HsToken_AGField Identifier
field_ Identifier
attr_ Pos
pos_ Maybe String
rdesc_
sem_HsToken ( HsToken String
value_ Pos
pos_ ) = String -> Pos -> T_HsToken
sem_HsToken_HsToken String
value_ Pos
pos_
sem_HsToken ( CharToken String
value_ Pos
pos_ ) = String -> Pos -> T_HsToken
sem_HsToken_CharToken String
value_ Pos
pos_
sem_HsToken ( StrToken String
value_ Pos
pos_ ) = String -> Pos -> T_HsToken
sem_HsToken_StrToken String
value_ Pos
pos_
sem_HsToken ( Err String
mesg_ Pos
pos_ ) = String -> Pos -> T_HsToken
sem_HsToken_Err String
mesg_ Pos
pos_

-- semantic domain
newtype T_HsToken  = T_HsToken {
                               T_HsToken -> Identity T_HsToken_s2
attach_T_HsToken :: Identity (T_HsToken_s2 )
                               }
newtype T_HsToken_s2  = C_HsToken_s2 {
                                     T_HsToken_s2 -> T_HsToken_v1
inv_HsToken_s2 :: (T_HsToken_v1 )
                                     }
data T_HsToken_s3  = C_HsToken_s3
type T_HsToken_v1  = (T_HsToken_vIn1 ) -> (T_HsToken_vOut1 )
data T_HsToken_vIn1  = T_HsToken_vIn1 ([(Identifier,Type,ChildKind)]) ([Identifier]) ([(Identifier,Identifier)]) (Identifier) ([Identifier]) (Identifier) (Options)
data T_HsToken_vOut1  = T_HsToken_vOut1 (Seq Error) (HsToken) ((Pos,String)) ([(Identifier,Identifier)]) (Seq Identifier) ([Identifier])
{-# NOINLINE sem_HsToken_AGLocal #-}
sem_HsToken_AGLocal :: (Identifier) -> (Pos) -> (Maybe String) -> T_HsToken 
sem_HsToken_AGLocal :: Identifier -> Pos -> Maybe String -> T_HsToken
sem_HsToken_AGLocal Identifier
arg_var_ Pos
arg_pos_ Maybe String
arg_rdesc_ = Identity T_HsToken_s2 -> T_HsToken
T_HsToken (forall (m :: * -> *) a. Monad m => a -> m a
return T_HsToken_s2
st2) where
   {-# NOINLINE st2 #-}
   st2 :: T_HsToken_s2
st2 = let
      v1 :: T_HsToken_v1 
      v1 :: T_HsToken_v1
v1 = \ (T_HsToken_vIn1 [(Identifier, Type, ChildKind)]
_lhsIallfields [Identifier]
_lhsIallnts [(Identifier, Identifier)]
_lhsIattrs Identifier
_lhsIcon [Identifier]
_lhsIfieldnames Identifier
_lhsInt Options
_lhsIoptions) -> ( let
         _tkAsLocal :: HsToken
_tkAsLocal = Pos -> Maybe String -> Identifier -> HsToken
rule0 Pos
arg_pos_ Maybe String
arg_rdesc_ Identifier
arg_var_
         _tkAsField :: HsToken
_tkAsField = Pos -> Maybe String -> Identifier -> HsToken
rule1 Pos
arg_pos_ Maybe String
arg_rdesc_ Identifier
arg_var_
         (Seq Error
_errors,HsToken
_output,(Pos, String)
_tok,[Identifier]
_usedLocals) = forall {b} {a}.
[(Identifier, Type, ChildKind)]
-> [Identifier]
-> [(Identifier, Identifier)]
-> Identifier
-> [Identifier]
-> Identifier
-> Options
-> b
-> b
-> a
-> Identifier
-> (Seq Error, b, (a, String), [Identifier])
rule2 [(Identifier, Type, ChildKind)]
_lhsIallfields [Identifier]
_lhsIallnts [(Identifier, Identifier)]
_lhsIattrs Identifier
_lhsIcon [Identifier]
_lhsIfieldnames Identifier
_lhsInt Options
_lhsIoptions HsToken
_tkAsField HsToken
_tkAsLocal Pos
arg_pos_ Identifier
arg_var_
         _lhsOusedFields :: Seq Identifier
         _lhsOusedFields :: Seq Identifier
_lhsOusedFields = [Identifier] -> Identifier -> Seq Identifier
rule3 [Identifier]
_lhsIfieldnames Identifier
arg_var_
         _lhsOerrors :: Seq Error
         _lhsOerrors :: Seq Error
_lhsOerrors = forall a. a -> a
rule4 Seq Error
_errors
         _lhsOusedAttrs :: [(Identifier,Identifier)]
         _lhsOusedAttrs :: [(Identifier, Identifier)]
_lhsOusedAttrs = forall {a}. () -> [a]
rule5  ()
         _lhsOusedLocals :: [Identifier]
         _lhsOusedLocals :: [Identifier]
_lhsOusedLocals = forall a. a -> a
rule6 [Identifier]
_usedLocals
         _lhsOoutput :: HsToken
         _lhsOoutput :: HsToken
_lhsOoutput = forall a. a -> a
rule7 HsToken
_output
         _lhsOtok :: (Pos,String)
         _lhsOtok :: (Pos, String)
_lhsOtok = forall a. a -> a
rule8 (Pos, String)
_tok
         __result_ :: T_HsToken_vOut1
__result_ = Seq Error
-> HsToken
-> (Pos, String)
-> [(Identifier, Identifier)]
-> Seq Identifier
-> [Identifier]
-> T_HsToken_vOut1
T_HsToken_vOut1 Seq Error
_lhsOerrors HsToken
_lhsOoutput (Pos, String)
_lhsOtok [(Identifier, Identifier)]
_lhsOusedAttrs Seq Identifier
_lhsOusedFields [Identifier]
_lhsOusedLocals
         in T_HsToken_vOut1
__result_ )
     in T_HsToken_v1 -> T_HsToken_s2
C_HsToken_s2 T_HsToken_v1
v1
   {-# INLINE rule0 #-}
   {-# LINE 66 "src-ag/SemHsTokens.ag" #-}
   rule0 = \ pos_ rdesc_ var_ ->
                                {-# LINE 66 "src-ag/SemHsTokens.ag" #-}
                                AGLocal var_ pos_ rdesc_
                                {-# LINE 95 "src-generated/SemHsTokens.hs" #-}
   {-# INLINE rule1 #-}
   {-# LINE 67 "src-ag/SemHsTokens.ag" #-}
   rule1 = \ pos_ rdesc_ var_ ->
                                {-# LINE 67 "src-ag/SemHsTokens.ag" #-}
                                AGField _LOC var_ pos_ rdesc_
                                {-# LINE 101 "src-generated/SemHsTokens.hs" #-}
   {-# INLINE rule2 #-}
   {-# LINE 69 "src-ag/SemHsTokens.ag" #-}
   rule2 = \ ((_lhsIallfields) :: [(Identifier,Type,ChildKind)]) ((_lhsIallnts) :: [Identifier]) ((_lhsIattrs) :: [(Identifier,Identifier)]) ((_lhsIcon) :: Identifier) ((_lhsIfieldnames) :: [Identifier]) ((_lhsInt) :: Identifier) ((_lhsIoptions) :: Options) _tkAsField _tkAsLocal pos_ var_ ->
                       {-# LINE 69 "src-ag/SemHsTokens.ag" #-}
                       if var_ `elem` _lhsIfieldnames
                       then if  isNTname _lhsIallnts (lookup var_ (map (\(n,t,_) -> (n,t)) _lhsIallfields))
                            then (Seq.singleton(ChildAsLocal _lhsInt _lhsIcon var_), _tkAsLocal    ,(pos_,fieldname var_), []    )
                            else (Seq.empty, _tkAsLocal    , (pos_,fieldname var_), []    )
                       else if (_LOC,var_) `elem` _lhsIattrs
                            then (Seq.empty                                      , _tkAsField    , (pos_,locname _lhsIoptions var_), [var_])
                            else (Seq.singleton(UndefLocal _lhsInt _lhsIcon var_), _tkAsField    , (pos_,locname _lhsIoptions var_), []    )
                       {-# LINE 113 "src-generated/SemHsTokens.hs" #-}
   {-# INLINE rule3 #-}
   {-# LINE 104 "src-ag/SemHsTokens.ag" #-}
   rule3 = \ ((_lhsIfieldnames) :: [Identifier]) var_ ->
                               {-# LINE 104 "src-ag/SemHsTokens.ag" #-}
                               if var_ `elem` _lhsIfieldnames
                                then Seq.singleton var_
                                else Seq.empty
                               {-# LINE 121 "src-generated/SemHsTokens.hs" #-}
   {-# INLINE rule4 #-}
   rule4 = \ _errors ->
     _errors
   {-# INLINE rule5 #-}
   rule5 = \  (_ :: ()) ->
     []
   {-# INLINE rule6 #-}
   rule6 = \ _usedLocals ->
     _usedLocals
   {-# INLINE rule7 #-}
   rule7 = \ _output ->
     _output
   {-# INLINE rule8 #-}
   rule8 = \ _tok ->
     _tok
{-# NOINLINE sem_HsToken_AGField #-}
sem_HsToken_AGField :: (Identifier) -> (Identifier) -> (Pos) -> (Maybe String) -> T_HsToken 
sem_HsToken_AGField :: Identifier -> Identifier -> Pos -> Maybe String -> T_HsToken
sem_HsToken_AGField Identifier
arg_field_ Identifier
arg_attr_ Pos
arg_pos_ Maybe String
arg_rdesc_ = Identity T_HsToken_s2 -> T_HsToken
T_HsToken (forall (m :: * -> *) a. Monad m => a -> m a
return T_HsToken_s2
st2) where
   {-# NOINLINE st2 #-}
   st2 :: T_HsToken_s2
st2 = let
      v1 :: T_HsToken_v1 
      v1 :: T_HsToken_v1
v1 = \ (T_HsToken_vIn1 [(Identifier, Type, ChildKind)]
_lhsIallfields [Identifier]
_lhsIallnts [(Identifier, Identifier)]
_lhsIattrs Identifier
_lhsIcon [Identifier]
_lhsIfieldnames Identifier
_lhsInt Options
_lhsIoptions) -> ( let
         _lhsOerrors :: Seq Error
         _lhsOerrors :: Seq Error
_lhsOerrors = [(Identifier, Identifier)]
-> Identifier
-> [Identifier]
-> Identifier
-> Identifier
-> Identifier
-> Seq Error
rule9 [(Identifier, Identifier)]
_lhsIattrs Identifier
_lhsIcon [Identifier]
_lhsIfieldnames Identifier
_lhsInt Identifier
arg_attr_ Identifier
arg_field_
         _lhsOusedAttrs :: [(Identifier,Identifier)]
         _lhsOusedLocals :: [Identifier]
         ([(Identifier, Identifier)]
_lhsOusedAttrs,[Identifier]
_lhsOusedLocals) = forall {b}. b -> Identifier -> ([(Identifier, b)], [b])
rule10 Identifier
arg_attr_ Identifier
arg_field_
         _addTrace :: String -> String
_addTrace = Identifier -> Identifier -> Maybe String -> String -> String
rule11 Identifier
arg_attr_ Identifier
arg_field_ Maybe String
arg_rdesc_
         _lhsOtok :: (Pos,String)
         _lhsOtok :: (Pos, String)
_lhsOtok = forall {b} {a}.
(String -> b) -> Options -> Identifier -> Identifier -> a -> (a, b)
rule12 String -> String
_addTrace Options
_lhsIoptions Identifier
arg_attr_ Identifier
arg_field_ Pos
arg_pos_
         _lhsOusedFields :: Seq Identifier
         _lhsOusedFields :: Seq Identifier
_lhsOusedFields = forall {a}. () -> Seq a
rule13  ()
         _output :: HsToken
_output = Identifier -> Identifier -> Pos -> Maybe String -> HsToken
rule14 Identifier
arg_attr_ Identifier
arg_field_ Pos
arg_pos_ Maybe String
arg_rdesc_
         _lhsOoutput :: HsToken
         _lhsOoutput :: HsToken
_lhsOoutput = forall a. a -> a
rule15 HsToken
_output
         __result_ :: T_HsToken_vOut1
__result_ = Seq Error
-> HsToken
-> (Pos, String)
-> [(Identifier, Identifier)]
-> Seq Identifier
-> [Identifier]
-> T_HsToken_vOut1
T_HsToken_vOut1 Seq Error
_lhsOerrors HsToken
_lhsOoutput (Pos, String)
_lhsOtok [(Identifier, Identifier)]
_lhsOusedAttrs Seq Identifier
_lhsOusedFields [Identifier]
_lhsOusedLocals
         in T_HsToken_vOut1
__result_ )
     in T_HsToken_v1 -> T_HsToken_s2
C_HsToken_s2 T_HsToken_v1
v1
   {-# INLINE rule9 #-}
   {-# LINE 78 "src-ag/SemHsTokens.ag" #-}
   rule9 = \ ((_lhsIattrs) :: [(Identifier,Identifier)]) ((_lhsIcon) :: Identifier) ((_lhsIfieldnames) :: [Identifier]) ((_lhsInt) :: Identifier) attr_ field_ ->
                             {-# LINE 78 "src-ag/SemHsTokens.ag" #-}
                             if (field_,attr_) `elem` _lhsIattrs
                             then Seq.empty
                             else if not(field_ `elem` (_LHS : _LOC: _lhsIfieldnames))
                                  then Seq.singleton (UndefChild _lhsInt _lhsIcon field_)
                                  else Seq.singleton (UndefAttr _lhsInt _lhsIcon field_ attr_ False)
                             {-# LINE 169 "src-generated/SemHsTokens.hs" #-}
   {-# INLINE rule10 #-}
   {-# LINE 93 "src-ag/SemHsTokens.ag" #-}
   rule10 = \ attr_ field_ ->
                  {-# LINE 93 "src-ag/SemHsTokens.ag" #-}
                  if field_ == _LOC
                  then ([], [attr_])
                  else ([(field_,attr_)], [])
                  {-# LINE 177 "src-generated/SemHsTokens.hs" #-}
   {-# INLINE rule11 #-}
   {-# LINE 123 "src-ag/SemHsTokens.ag" #-}
   rule11 = \ attr_ field_ rdesc_ ->
                        {-# LINE 123 "src-ag/SemHsTokens.ag" #-}
                        case rdesc_ of
                          Just d  -> \x -> "(trace " ++ show (d ++ " -> " ++ show field_ ++ "." ++ show attr_) ++ " (" ++ x ++ "))"
                          Nothing -> id
                        {-# LINE 185 "src-generated/SemHsTokens.hs" #-}
   {-# INLINE rule12 #-}
   {-# LINE 126 "src-ag/SemHsTokens.ag" #-}
   rule12 = \ _addTrace ((_lhsIoptions) :: Options) attr_ field_ pos_ ->
                   {-# LINE 126 "src-ag/SemHsTokens.ag" #-}
                   (pos_, _addTrace     $ attrname _lhsIoptions True field_ attr_)
                   {-# LINE 191 "src-generated/SemHsTokens.hs" #-}
   {-# INLINE rule13 #-}
   rule13 = \  (_ :: ()) ->
     Seq.empty
   {-# INLINE rule14 #-}
   rule14 = \ attr_ field_ pos_ rdesc_ ->
     AGField field_ attr_ pos_ rdesc_
   {-# INLINE rule15 #-}
   rule15 = \ _output ->
     _output
{-# NOINLINE sem_HsToken_HsToken #-}
sem_HsToken_HsToken :: (String) -> (Pos) -> T_HsToken 
sem_HsToken_HsToken :: String -> Pos -> T_HsToken
sem_HsToken_HsToken String
arg_value_ Pos
arg_pos_ = Identity T_HsToken_s2 -> T_HsToken
T_HsToken (forall (m :: * -> *) a. Monad m => a -> m a
return T_HsToken_s2
st2) where
   {-# NOINLINE st2 #-}
   st2 :: T_HsToken_s2
st2 = let
      v1 :: T_HsToken_v1 
      v1 :: T_HsToken_v1
v1 = \ (T_HsToken_vIn1 [(Identifier, Type, ChildKind)]
_lhsIallfields [Identifier]
_lhsIallnts [(Identifier, Identifier)]
_lhsIattrs Identifier
_lhsIcon [Identifier]
_lhsIfieldnames Identifier
_lhsInt Options
_lhsIoptions) -> ( let
         _lhsOtok :: (Pos,String)
         _lhsOtok :: (Pos, String)
_lhsOtok = forall {a} {b}. a -> b -> (a, b)
rule16 Pos
arg_pos_ String
arg_value_
         _lhsOerrors :: Seq Error
         _lhsOerrors :: Seq Error
_lhsOerrors = forall {a}. () -> Seq a
rule17  ()
         _lhsOusedAttrs :: [(Identifier,Identifier)]
         _lhsOusedAttrs :: [(Identifier, Identifier)]
_lhsOusedAttrs = forall {a}. () -> [a]
rule18  ()
         _lhsOusedFields :: Seq Identifier
         _lhsOusedFields :: Seq Identifier
_lhsOusedFields = forall {a}. () -> Seq a
rule19  ()
         _lhsOusedLocals :: [Identifier]
         _lhsOusedLocals :: [Identifier]
_lhsOusedLocals = forall {a}. () -> [a]
rule20  ()
         _output :: HsToken
_output = Pos -> String -> HsToken
rule21 Pos
arg_pos_ String
arg_value_
         _lhsOoutput :: HsToken
         _lhsOoutput :: HsToken
_lhsOoutput = forall a. a -> a
rule22 HsToken
_output
         __result_ :: T_HsToken_vOut1
__result_ = Seq Error
-> HsToken
-> (Pos, String)
-> [(Identifier, Identifier)]
-> Seq Identifier
-> [Identifier]
-> T_HsToken_vOut1
T_HsToken_vOut1 Seq Error
_lhsOerrors HsToken
_lhsOoutput (Pos, String)
_lhsOtok [(Identifier, Identifier)]
_lhsOusedAttrs Seq Identifier
_lhsOusedFields [Identifier]
_lhsOusedLocals
         in T_HsToken_vOut1
__result_ )
     in T_HsToken_v1 -> T_HsToken_s2
C_HsToken_s2 T_HsToken_v1
v1
   {-# INLINE rule16 #-}
   {-# LINE 128 "src-ag/SemHsTokens.ag" #-}
   rule16 = \ pos_ value_ ->
                         {-# LINE 128 "src-ag/SemHsTokens.ag" #-}
                         (pos_, value_)
                         {-# LINE 229 "src-generated/SemHsTokens.hs" #-}
   {-# INLINE rule17 #-}
   rule17 = \  (_ :: ()) ->
     Seq.empty
   {-# INLINE rule18 #-}
   rule18 = \  (_ :: ()) ->
     []
   {-# INLINE rule19 #-}
   rule19 = \  (_ :: ()) ->
     Seq.empty
   {-# INLINE rule20 #-}
   rule20 = \  (_ :: ()) ->
     []
   {-# INLINE rule21 #-}
   rule21 = \ pos_ value_ ->
     HsToken value_ pos_
   {-# INLINE rule22 #-}
   rule22 = \ _output ->
     _output
{-# NOINLINE sem_HsToken_CharToken #-}
sem_HsToken_CharToken :: (String) -> (Pos) -> T_HsToken 
sem_HsToken_CharToken :: String -> Pos -> T_HsToken
sem_HsToken_CharToken String
arg_value_ Pos
arg_pos_ = Identity T_HsToken_s2 -> T_HsToken
T_HsToken (forall (m :: * -> *) a. Monad m => a -> m a
return T_HsToken_s2
st2) where
   {-# NOINLINE st2 #-}
   st2 :: T_HsToken_s2
st2 = let
      v1 :: T_HsToken_v1 
      v1 :: T_HsToken_v1
v1 = \ (T_HsToken_vIn1 [(Identifier, Type, ChildKind)]
_lhsIallfields [Identifier]
_lhsIallnts [(Identifier, Identifier)]
_lhsIattrs Identifier
_lhsIcon [Identifier]
_lhsIfieldnames Identifier
_lhsInt Options
_lhsIoptions) -> ( let
         _lhsOtok :: (Pos,String)
         _lhsOtok :: (Pos, String)
_lhsOtok = forall {a}. a -> String -> (a, String)
rule23 Pos
arg_pos_ String
arg_value_
         _lhsOerrors :: Seq Error
         _lhsOerrors :: Seq Error
_lhsOerrors = forall {a}. () -> Seq a
rule24  ()
         _lhsOusedAttrs :: [(Identifier,Identifier)]
         _lhsOusedAttrs :: [(Identifier, Identifier)]
_lhsOusedAttrs = forall {a}. () -> [a]
rule25  ()
         _lhsOusedFields :: Seq Identifier
         _lhsOusedFields :: Seq Identifier
_lhsOusedFields = forall {a}. () -> Seq a
rule26  ()
         _lhsOusedLocals :: [Identifier]
         _lhsOusedLocals :: [Identifier]
_lhsOusedLocals = forall {a}. () -> [a]
rule27  ()
         _output :: HsToken
_output = Pos -> String -> HsToken
rule28 Pos
arg_pos_ String
arg_value_
         _lhsOoutput :: HsToken
         _lhsOoutput :: HsToken
_lhsOoutput = forall a. a -> a
rule29 HsToken
_output
         __result_ :: T_HsToken_vOut1
__result_ = Seq Error
-> HsToken
-> (Pos, String)
-> [(Identifier, Identifier)]
-> Seq Identifier
-> [Identifier]
-> T_HsToken_vOut1
T_HsToken_vOut1 Seq Error
_lhsOerrors HsToken
_lhsOoutput (Pos, String)
_lhsOtok [(Identifier, Identifier)]
_lhsOusedAttrs Seq Identifier
_lhsOusedFields [Identifier]
_lhsOusedLocals
         in T_HsToken_vOut1
__result_ )
     in T_HsToken_v1 -> T_HsToken_s2
C_HsToken_s2 T_HsToken_v1
v1
   {-# INLINE rule23 #-}
   {-# LINE 130 "src-ag/SemHsTokens.ag" #-}
   rule23 = \ pos_ value_ ->
                           {-# LINE 130 "src-ag/SemHsTokens.ag" #-}
                           (pos_, if null value_
                                     then ""
                                     else showCharShort (head value_)
                           )
                           {-# LINE 279 "src-generated/SemHsTokens.hs" #-}
   {-# INLINE rule24 #-}
   rule24 = \  (_ :: ()) ->
     Seq.empty
   {-# INLINE rule25 #-}
   rule25 = \  (_ :: ()) ->
     []
   {-# INLINE rule26 #-}
   rule26 = \  (_ :: ()) ->
     Seq.empty
   {-# INLINE rule27 #-}
   rule27 = \  (_ :: ()) ->
     []
   {-# INLINE rule28 #-}
   rule28 = \ pos_ value_ ->
     CharToken value_ pos_
   {-# INLINE rule29 #-}
   rule29 = \ _output ->
     _output
{-# NOINLINE sem_HsToken_StrToken #-}
sem_HsToken_StrToken :: (String) -> (Pos) -> T_HsToken 
sem_HsToken_StrToken :: String -> Pos -> T_HsToken
sem_HsToken_StrToken String
arg_value_ Pos
arg_pos_ = Identity T_HsToken_s2 -> T_HsToken
T_HsToken (forall (m :: * -> *) a. Monad m => a -> m a
return T_HsToken_s2
st2) where
   {-# NOINLINE st2 #-}
   st2 :: T_HsToken_s2
st2 = let
      v1 :: T_HsToken_v1 
      v1 :: T_HsToken_v1
v1 = \ (T_HsToken_vIn1 [(Identifier, Type, ChildKind)]
_lhsIallfields [Identifier]
_lhsIallnts [(Identifier, Identifier)]
_lhsIattrs Identifier
_lhsIcon [Identifier]
_lhsIfieldnames Identifier
_lhsInt Options
_lhsIoptions) -> ( let
         _lhsOtok :: (Pos,String)
         _lhsOtok :: (Pos, String)
_lhsOtok = forall {a}. a -> String -> (a, String)
rule30 Pos
arg_pos_ String
arg_value_
         _lhsOerrors :: Seq Error
         _lhsOerrors :: Seq Error
_lhsOerrors = forall {a}. () -> Seq a
rule31  ()
         _lhsOusedAttrs :: [(Identifier,Identifier)]
         _lhsOusedAttrs :: [(Identifier, Identifier)]
_lhsOusedAttrs = forall {a}. () -> [a]
rule32  ()
         _lhsOusedFields :: Seq Identifier
         _lhsOusedFields :: Seq Identifier
_lhsOusedFields = forall {a}. () -> Seq a
rule33  ()
         _lhsOusedLocals :: [Identifier]
         _lhsOusedLocals :: [Identifier]
_lhsOusedLocals = forall {a}. () -> [a]
rule34  ()
         _output :: HsToken
_output = Pos -> String -> HsToken
rule35 Pos
arg_pos_ String
arg_value_
         _lhsOoutput :: HsToken
         _lhsOoutput :: HsToken
_lhsOoutput = forall a. a -> a
rule36 HsToken
_output
         __result_ :: T_HsToken_vOut1
__result_ = Seq Error
-> HsToken
-> (Pos, String)
-> [(Identifier, Identifier)]
-> Seq Identifier
-> [Identifier]
-> T_HsToken_vOut1
T_HsToken_vOut1 Seq Error
_lhsOerrors HsToken
_lhsOoutput (Pos, String)
_lhsOtok [(Identifier, Identifier)]
_lhsOusedAttrs Seq Identifier
_lhsOusedFields [Identifier]
_lhsOusedLocals
         in T_HsToken_vOut1
__result_ )
     in T_HsToken_v1 -> T_HsToken_s2
C_HsToken_s2 T_HsToken_v1
v1
   {-# INLINE rule30 #-}
   {-# LINE 135 "src-ag/SemHsTokens.ag" #-}
   rule30 = \ pos_ value_ ->
                           {-# LINE 135 "src-ag/SemHsTokens.ag" #-}
                           (pos_, showStrShort value_)
                           {-# LINE 326 "src-generated/SemHsTokens.hs" #-}
   {-# INLINE rule31 #-}
   rule31 = \  (_ :: ()) ->
     Seq.empty
   {-# INLINE rule32 #-}
   rule32 = \  (_ :: ()) ->
     []
   {-# INLINE rule33 #-}
   rule33 = \  (_ :: ()) ->
     Seq.empty
   {-# INLINE rule34 #-}
   rule34 = \  (_ :: ()) ->
     []
   {-# INLINE rule35 #-}
   rule35 = \ pos_ value_ ->
     StrToken value_ pos_
   {-# INLINE rule36 #-}
   rule36 = \ _output ->
     _output
{-# NOINLINE sem_HsToken_Err #-}
sem_HsToken_Err :: (String) -> (Pos) -> T_HsToken 
sem_HsToken_Err :: String -> Pos -> T_HsToken
sem_HsToken_Err String
arg_mesg_ Pos
arg_pos_ = Identity T_HsToken_s2 -> T_HsToken
T_HsToken (forall (m :: * -> *) a. Monad m => a -> m a
return T_HsToken_s2
st2) where
   {-# NOINLINE st2 #-}
   st2 :: T_HsToken_s2
st2 = let
      v1 :: T_HsToken_v1 
      v1 :: T_HsToken_v1
v1 = \ (T_HsToken_vIn1 [(Identifier, Type, ChildKind)]
_lhsIallfields [Identifier]
_lhsIallnts [(Identifier, Identifier)]
_lhsIattrs Identifier
_lhsIcon [Identifier]
_lhsIfieldnames Identifier
_lhsInt Options
_lhsIoptions) -> ( let
         _lhsOerrors :: Seq Error
         _lhsOerrors :: Seq Error
_lhsOerrors = String -> Pos -> Seq Error
rule37 String
arg_mesg_ Pos
arg_pos_
         _lhsOtok :: (Pos,String)
         _lhsOtok :: (Pos, String)
_lhsOtok = forall {a}. a -> (a, String)
rule38 Pos
arg_pos_
         _lhsOusedAttrs :: [(Identifier,Identifier)]
         _lhsOusedAttrs :: [(Identifier, Identifier)]
_lhsOusedAttrs = forall {a}. () -> [a]
rule39  ()
         _lhsOusedFields :: Seq Identifier
         _lhsOusedFields :: Seq Identifier
_lhsOusedFields = forall {a}. () -> Seq a
rule40  ()
         _lhsOusedLocals :: [Identifier]
         _lhsOusedLocals :: [Identifier]
_lhsOusedLocals = forall {a}. () -> [a]
rule41  ()
         _output :: HsToken
_output = String -> Pos -> HsToken
rule42 String
arg_mesg_ Pos
arg_pos_
         _lhsOoutput :: HsToken
         _lhsOoutput :: HsToken
_lhsOoutput = forall a. a -> a
rule43 HsToken
_output
         __result_ :: T_HsToken_vOut1
__result_ = Seq Error
-> HsToken
-> (Pos, String)
-> [(Identifier, Identifier)]
-> Seq Identifier
-> [Identifier]
-> T_HsToken_vOut1
T_HsToken_vOut1 Seq Error
_lhsOerrors HsToken
_lhsOoutput (Pos, String)
_lhsOtok [(Identifier, Identifier)]
_lhsOusedAttrs Seq Identifier
_lhsOusedFields [Identifier]
_lhsOusedLocals
         in T_HsToken_vOut1
__result_ )
     in T_HsToken_v1 -> T_HsToken_s2
C_HsToken_s2 T_HsToken_v1
v1
   {-# INLINE rule37 #-}
   {-# LINE 51 "src-ag/SemHsTokens.ag" #-}
   rule37 = \ mesg_ pos_ ->
                       {-# LINE 51 "src-ag/SemHsTokens.ag" #-}
                       let m = text mesg_
                       in Seq.singleton (CustomError False pos_ m)
                       {-# LINE 374 "src-generated/SemHsTokens.hs" #-}
   {-# INLINE rule38 #-}
   {-# LINE 136 "src-ag/SemHsTokens.ag" #-}
   rule38 = \ pos_ ->
                           {-# LINE 136 "src-ag/SemHsTokens.ag" #-}
                           (pos_, "")
                           {-# LINE 380 "src-generated/SemHsTokens.hs" #-}
   {-# INLINE rule39 #-}
   rule39 = \  (_ :: ()) ->
     []
   {-# INLINE rule40 #-}
   rule40 = \  (_ :: ()) ->
     Seq.empty
   {-# INLINE rule41 #-}
   rule41 = \  (_ :: ()) ->
     []
   {-# INLINE rule42 #-}
   rule42 = \ mesg_ pos_ ->
     Err mesg_ pos_
   {-# INLINE rule43 #-}
   rule43 = \ _output ->
     _output

-- HsTokens ----------------------------------------------------
-- wrapper
data Inh_HsTokens  = Inh_HsTokens { Inh_HsTokens -> [(Identifier, Type, ChildKind)]
allfields_Inh_HsTokens :: ([(Identifier,Type,ChildKind)]), Inh_HsTokens -> [Identifier]
allnts_Inh_HsTokens :: ([Identifier]), Inh_HsTokens -> [(Identifier, Identifier)]
attrs_Inh_HsTokens :: ([(Identifier,Identifier)]), Inh_HsTokens -> Identifier
con_Inh_HsTokens :: (Identifier), Inh_HsTokens -> [Identifier]
fieldnames_Inh_HsTokens :: ([Identifier]), Inh_HsTokens -> Identifier
nt_Inh_HsTokens :: (Identifier), Inh_HsTokens -> Options
options_Inh_HsTokens :: (Options) }
data Syn_HsTokens  = Syn_HsTokens { Syn_HsTokens -> Seq Error
errors_Syn_HsTokens :: (Seq Error), Syn_HsTokens -> HsTokens
output_Syn_HsTokens :: (HsTokens), Syn_HsTokens -> [(Pos, String)]
tks_Syn_HsTokens :: ([(Pos,String)]), Syn_HsTokens -> [(Identifier, Identifier)]
usedAttrs_Syn_HsTokens :: ([(Identifier,Identifier)]), Syn_HsTokens -> Seq Identifier
usedFields_Syn_HsTokens :: (Seq Identifier), Syn_HsTokens -> [Identifier]
usedLocals_Syn_HsTokens :: ([Identifier]) }
{-# INLINABLE wrap_HsTokens #-}
wrap_HsTokens :: T_HsTokens  -> Inh_HsTokens  -> (Syn_HsTokens )
wrap_HsTokens :: T_HsTokens -> Inh_HsTokens -> Syn_HsTokens
wrap_HsTokens (T_HsTokens Identity T_HsTokens_s5
act) (Inh_HsTokens [(Identifier, Type, ChildKind)]
_lhsIallfields [Identifier]
_lhsIallnts [(Identifier, Identifier)]
_lhsIattrs Identifier
_lhsIcon [Identifier]
_lhsIfieldnames Identifier
_lhsInt Options
_lhsIoptions) =
   forall a. Identity a -> a
Control.Monad.Identity.runIdentity (
     do T_HsTokens_s5
sem <- Identity T_HsTokens_s5
act
        let arg4 :: T_HsTokens_vIn4
arg4 = [(Identifier, Type, ChildKind)]
-> [Identifier]
-> [(Identifier, Identifier)]
-> Identifier
-> [Identifier]
-> Identifier
-> Options
-> T_HsTokens_vIn4
T_HsTokens_vIn4 [(Identifier, Type, ChildKind)]
_lhsIallfields [Identifier]
_lhsIallnts [(Identifier, Identifier)]
_lhsIattrs Identifier
_lhsIcon [Identifier]
_lhsIfieldnames Identifier
_lhsInt Options
_lhsIoptions
        (T_HsTokens_vOut4 Seq Error
_lhsOerrors HsTokens
_lhsOoutput [(Pos, String)]
_lhsOtks [(Identifier, Identifier)]
_lhsOusedAttrs Seq Identifier
_lhsOusedFields [Identifier]
_lhsOusedLocals) <- forall (m :: * -> *) a. Monad m => a -> m a
return (T_HsTokens_s5 -> T_HsTokens_v4
inv_HsTokens_s5 T_HsTokens_s5
sem T_HsTokens_vIn4
arg4)
        forall (m :: * -> *) a. Monad m => a -> m a
return (Seq Error
-> HsTokens
-> [(Pos, String)]
-> [(Identifier, Identifier)]
-> Seq Identifier
-> [Identifier]
-> Syn_HsTokens
Syn_HsTokens Seq Error
_lhsOerrors HsTokens
_lhsOoutput [(Pos, String)]
_lhsOtks [(Identifier, Identifier)]
_lhsOusedAttrs Seq Identifier
_lhsOusedFields [Identifier]
_lhsOusedLocals)
   )

-- cata
{-# NOINLINE sem_HsTokens #-}
sem_HsTokens :: HsTokens  -> T_HsTokens 
sem_HsTokens :: HsTokens -> T_HsTokens
sem_HsTokens HsTokens
list = forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
Prelude.foldr T_HsToken -> T_HsTokens -> T_HsTokens
sem_HsTokens_Cons T_HsTokens
sem_HsTokens_Nil (forall a b. (a -> b) -> [a] -> [b]
Prelude.map HsToken -> T_HsToken
sem_HsToken HsTokens
list)

-- semantic domain
newtype T_HsTokens  = T_HsTokens {
                                 T_HsTokens -> Identity T_HsTokens_s5
attach_T_HsTokens :: Identity (T_HsTokens_s5 )
                                 }
newtype T_HsTokens_s5  = C_HsTokens_s5 {
                                       T_HsTokens_s5 -> T_HsTokens_v4
inv_HsTokens_s5 :: (T_HsTokens_v4 )
                                       }
data T_HsTokens_s6  = C_HsTokens_s6
type T_HsTokens_v4  = (T_HsTokens_vIn4 ) -> (T_HsTokens_vOut4 )
data T_HsTokens_vIn4  = T_HsTokens_vIn4 ([(Identifier,Type,ChildKind)]) ([Identifier]) ([(Identifier,Identifier)]) (Identifier) ([Identifier]) (Identifier) (Options)
data T_HsTokens_vOut4  = T_HsTokens_vOut4 (Seq Error) (HsTokens) ([(Pos,String)]) ([(Identifier,Identifier)]) (Seq Identifier) ([Identifier])
{-# NOINLINE sem_HsTokens_Cons #-}
sem_HsTokens_Cons :: T_HsToken  -> T_HsTokens  -> T_HsTokens 
sem_HsTokens_Cons :: T_HsToken -> T_HsTokens -> T_HsTokens
sem_HsTokens_Cons T_HsToken
arg_hd_ T_HsTokens
arg_tl_ = Identity T_HsTokens_s5 -> T_HsTokens
T_HsTokens (forall (m :: * -> *) a. Monad m => a -> m a
return T_HsTokens_s5
st5) where
   {-# NOINLINE st5 #-}
   st5 :: T_HsTokens_s5
st5 = let
      v4 :: T_HsTokens_v4 
      v4 :: T_HsTokens_v4
v4 = \ (T_HsTokens_vIn4 [(Identifier, Type, ChildKind)]
_lhsIallfields [Identifier]
_lhsIallnts [(Identifier, Identifier)]
_lhsIattrs Identifier
_lhsIcon [Identifier]
_lhsIfieldnames Identifier
_lhsInt Options
_lhsIoptions) -> ( let
         _hdX2 :: T_HsToken_s2
_hdX2 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_HsToken -> Identity T_HsToken_s2
attach_T_HsToken (T_HsToken
arg_hd_))
         _tlX5 :: T_HsTokens_s5
_tlX5 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_HsTokens -> Identity T_HsTokens_s5
attach_T_HsTokens (T_HsTokens
arg_tl_))
         (T_HsToken_vOut1 Seq Error
_hdIerrors HsToken
_hdIoutput (Pos, String)
_hdItok [(Identifier, Identifier)]
_hdIusedAttrs Seq Identifier
_hdIusedFields [Identifier]
_hdIusedLocals) = T_HsToken_s2 -> T_HsToken_v1
inv_HsToken_s2 T_HsToken_s2
_hdX2 ([(Identifier, Type, ChildKind)]
-> [Identifier]
-> [(Identifier, Identifier)]
-> Identifier
-> [Identifier]
-> Identifier
-> Options
-> T_HsToken_vIn1
T_HsToken_vIn1 [(Identifier, Type, ChildKind)]
_hdOallfields [Identifier]
_hdOallnts [(Identifier, Identifier)]
_hdOattrs Identifier
_hdOcon [Identifier]
_hdOfieldnames Identifier
_hdOnt Options
_hdOoptions)
         (T_HsTokens_vOut4 Seq Error
_tlIerrors HsTokens
_tlIoutput [(Pos, String)]
_tlItks [(Identifier, Identifier)]
_tlIusedAttrs Seq Identifier
_tlIusedFields [Identifier]
_tlIusedLocals) = T_HsTokens_s5 -> T_HsTokens_v4
inv_HsTokens_s5 T_HsTokens_s5
_tlX5 ([(Identifier, Type, ChildKind)]
-> [Identifier]
-> [(Identifier, Identifier)]
-> Identifier
-> [Identifier]
-> Identifier
-> Options
-> T_HsTokens_vIn4
T_HsTokens_vIn4 [(Identifier, Type, ChildKind)]
_tlOallfields [Identifier]
_tlOallnts [(Identifier, Identifier)]
_tlOattrs Identifier
_tlOcon [Identifier]
_tlOfieldnames Identifier
_tlOnt Options
_tlOoptions)
         _lhsOtks :: [(Pos,String)]
         _lhsOtks :: [(Pos, String)]
_lhsOtks = (Pos, String) -> [(Pos, String)] -> [(Pos, String)]
rule44 (Pos, String)
_hdItok [(Pos, String)]
_tlItks
         _lhsOerrors :: Seq Error
         _lhsOerrors :: Seq Error
_lhsOerrors = Seq Error -> Seq Error -> Seq Error
rule45 Seq Error
_hdIerrors Seq Error
_tlIerrors
         _lhsOusedAttrs :: [(Identifier,Identifier)]
         _lhsOusedAttrs :: [(Identifier, Identifier)]
_lhsOusedAttrs = [(Identifier, Identifier)]
-> [(Identifier, Identifier)] -> [(Identifier, Identifier)]
rule46 [(Identifier, Identifier)]
_hdIusedAttrs [(Identifier, Identifier)]
_tlIusedAttrs
         _lhsOusedFields :: Seq Identifier
         _lhsOusedFields :: Seq Identifier
_lhsOusedFields = Seq Identifier -> Seq Identifier -> Seq Identifier
rule47 Seq Identifier
_hdIusedFields Seq Identifier
_tlIusedFields
         _lhsOusedLocals :: [Identifier]
         _lhsOusedLocals :: [Identifier]
_lhsOusedLocals = [Identifier] -> [Identifier] -> [Identifier]
rule48 [Identifier]
_hdIusedLocals [Identifier]
_tlIusedLocals
         _output :: HsTokens
_output = HsToken -> HsTokens -> HsTokens
rule49 HsToken
_hdIoutput HsTokens
_tlIoutput
         _lhsOoutput :: HsTokens
         _lhsOoutput :: HsTokens
_lhsOoutput = forall a. a -> a
rule50 HsTokens
_output
         _hdOallfields :: [(Identifier, Type, ChildKind)]
_hdOallfields = [(Identifier, Type, ChildKind)] -> [(Identifier, Type, ChildKind)]
rule51 [(Identifier, Type, ChildKind)]
_lhsIallfields
         _hdOallnts :: [Identifier]
_hdOallnts = [Identifier] -> [Identifier]
rule52 [Identifier]
_lhsIallnts
         _hdOattrs :: [(Identifier, Identifier)]
_hdOattrs = [(Identifier, Identifier)] -> [(Identifier, Identifier)]
rule53 [(Identifier, Identifier)]
_lhsIattrs
         _hdOcon :: Identifier
_hdOcon = Identifier -> Identifier
rule54 Identifier
_lhsIcon
         _hdOfieldnames :: [Identifier]
_hdOfieldnames = [Identifier] -> [Identifier]
rule55 [Identifier]
_lhsIfieldnames
         _hdOnt :: Identifier
_hdOnt = Identifier -> Identifier
rule56 Identifier
_lhsInt
         _hdOoptions :: Options
_hdOoptions = Options -> Options
rule57 Options
_lhsIoptions
         _tlOallfields :: [(Identifier, Type, ChildKind)]
_tlOallfields = [(Identifier, Type, ChildKind)] -> [(Identifier, Type, ChildKind)]
rule58 [(Identifier, Type, ChildKind)]
_lhsIallfields
         _tlOallnts :: [Identifier]
_tlOallnts = [Identifier] -> [Identifier]
rule59 [Identifier]
_lhsIallnts
         _tlOattrs :: [(Identifier, Identifier)]
_tlOattrs = [(Identifier, Identifier)] -> [(Identifier, Identifier)]
rule60 [(Identifier, Identifier)]
_lhsIattrs
         _tlOcon :: Identifier
_tlOcon = Identifier -> Identifier
rule61 Identifier
_lhsIcon
         _tlOfieldnames :: [Identifier]
_tlOfieldnames = [Identifier] -> [Identifier]
rule62 [Identifier]
_lhsIfieldnames
         _tlOnt :: Identifier
_tlOnt = Identifier -> Identifier
rule63 Identifier
_lhsInt
         _tlOoptions :: Options
_tlOoptions = Options -> Options
rule64 Options
_lhsIoptions
         __result_ :: T_HsTokens_vOut4
__result_ = Seq Error
-> HsTokens
-> [(Pos, String)]
-> [(Identifier, Identifier)]
-> Seq Identifier
-> [Identifier]
-> T_HsTokens_vOut4
T_HsTokens_vOut4 Seq Error
_lhsOerrors HsTokens
_lhsOoutput [(Pos, String)]
_lhsOtks [(Identifier, Identifier)]
_lhsOusedAttrs Seq Identifier
_lhsOusedFields [Identifier]
_lhsOusedLocals
         in T_HsTokens_vOut4
__result_ )
     in T_HsTokens_v4 -> T_HsTokens_s5
C_HsTokens_s5 T_HsTokens_v4
v4
   {-# INLINE rule44 #-}
   {-# LINE 118 "src-ag/SemHsTokens.ag" #-}
   rule44 = \ ((_hdItok) :: (Pos,String)) ((_tlItks) :: [(Pos,String)]) ->
                     {-# LINE 118 "src-ag/SemHsTokens.ag" #-}
                     _hdItok : _tlItks
                     {-# LINE 473 "src-generated/SemHsTokens.hs" #-}
   {-# INLINE rule45 #-}
   rule45 = \ ((_hdIerrors) :: Seq Error) ((_tlIerrors) :: Seq Error) ->
     _hdIerrors Seq.>< _tlIerrors
   {-# INLINE rule46 #-}
   rule46 = \ ((_hdIusedAttrs) :: [(Identifier,Identifier)]) ((_tlIusedAttrs) :: [(Identifier,Identifier)]) ->
     _hdIusedAttrs ++ _tlIusedAttrs
   {-# INLINE rule47 #-}
   rule47 = \ ((_hdIusedFields) :: Seq Identifier) ((_tlIusedFields) :: Seq Identifier) ->
     _hdIusedFields Seq.>< _tlIusedFields
   {-# INLINE rule48 #-}
   rule48 = \ ((_hdIusedLocals) :: [Identifier]) ((_tlIusedLocals) :: [Identifier]) ->
     _hdIusedLocals ++ _tlIusedLocals
   {-# INLINE rule49 #-}
   rule49 = \ ((_hdIoutput) :: HsToken) ((_tlIoutput) :: HsTokens) ->
     (:) _hdIoutput _tlIoutput
   {-# INLINE rule50 #-}
   rule50 = \ _output ->
     _output
   {-# INLINE rule51 #-}
   rule51 = \ ((_lhsIallfields) :: [(Identifier,Type,ChildKind)]) ->
     _lhsIallfields
   {-# INLINE rule52 #-}
   rule52 = \ ((_lhsIallnts) :: [Identifier]) ->
     _lhsIallnts
   {-# INLINE rule53 #-}
   rule53 = \ ((_lhsIattrs) :: [(Identifier,Identifier)]) ->
     _lhsIattrs
   {-# INLINE rule54 #-}
   rule54 = \ ((_lhsIcon) :: Identifier) ->
     _lhsIcon
   {-# INLINE rule55 #-}
   rule55 = \ ((_lhsIfieldnames) :: [Identifier]) ->
     _lhsIfieldnames
   {-# INLINE rule56 #-}
   rule56 = \ ((_lhsInt) :: Identifier) ->
     _lhsInt
   {-# INLINE rule57 #-}
   rule57 = \ ((_lhsIoptions) :: Options) ->
     _lhsIoptions
   {-# INLINE rule58 #-}
   rule58 = \ ((_lhsIallfields) :: [(Identifier,Type,ChildKind)]) ->
     _lhsIallfields
   {-# INLINE rule59 #-}
   rule59 = \ ((_lhsIallnts) :: [Identifier]) ->
     _lhsIallnts
   {-# INLINE rule60 #-}
   rule60 = \ ((_lhsIattrs) :: [(Identifier,Identifier)]) ->
     _lhsIattrs
   {-# INLINE rule61 #-}
   rule61 = \ ((_lhsIcon) :: Identifier) ->
     _lhsIcon
   {-# INLINE rule62 #-}
   rule62 = \ ((_lhsIfieldnames) :: [Identifier]) ->
     _lhsIfieldnames
   {-# INLINE rule63 #-}
   rule63 = \ ((_lhsInt) :: Identifier) ->
     _lhsInt
   {-# INLINE rule64 #-}
   rule64 = \ ((_lhsIoptions) :: Options) ->
     _lhsIoptions
{-# NOINLINE sem_HsTokens_Nil #-}
sem_HsTokens_Nil ::  T_HsTokens 
sem_HsTokens_Nil :: T_HsTokens
sem_HsTokens_Nil  = Identity T_HsTokens_s5 -> T_HsTokens
T_HsTokens (forall (m :: * -> *) a. Monad m => a -> m a
return T_HsTokens_s5
st5) where
   {-# NOINLINE st5 #-}
   st5 :: T_HsTokens_s5
st5 = let
      v4 :: T_HsTokens_v4 
      v4 :: T_HsTokens_v4
v4 = \ (T_HsTokens_vIn4 [(Identifier, Type, ChildKind)]
_lhsIallfields [Identifier]
_lhsIallnts [(Identifier, Identifier)]
_lhsIattrs Identifier
_lhsIcon [Identifier]
_lhsIfieldnames Identifier
_lhsInt Options
_lhsIoptions) -> ( let
         _lhsOtks :: [(Pos,String)]
         _lhsOtks :: [(Pos, String)]
_lhsOtks = forall {a}. () -> [a]
rule65  ()
         _lhsOerrors :: Seq Error
         _lhsOerrors :: Seq Error
_lhsOerrors = forall {a}. () -> Seq a
rule66  ()
         _lhsOusedAttrs :: [(Identifier,Identifier)]
         _lhsOusedAttrs :: [(Identifier, Identifier)]
_lhsOusedAttrs = forall {a}. () -> [a]
rule67  ()
         _lhsOusedFields :: Seq Identifier
         _lhsOusedFields :: Seq Identifier
_lhsOusedFields = forall {a}. () -> Seq a
rule68  ()
         _lhsOusedLocals :: [Identifier]
         _lhsOusedLocals :: [Identifier]
_lhsOusedLocals = forall {a}. () -> [a]
rule69  ()
         _output :: [a]
_output = forall {a}. () -> [a]
rule70  ()
         _lhsOoutput :: HsTokens
         _lhsOoutput :: HsTokens
_lhsOoutput = forall a. a -> a
rule71 forall a. [a]
_output
         __result_ :: T_HsTokens_vOut4
__result_ = Seq Error
-> HsTokens
-> [(Pos, String)]
-> [(Identifier, Identifier)]
-> Seq Identifier
-> [Identifier]
-> T_HsTokens_vOut4
T_HsTokens_vOut4 Seq Error
_lhsOerrors HsTokens
_lhsOoutput [(Pos, String)]
_lhsOtks [(Identifier, Identifier)]
_lhsOusedAttrs Seq Identifier
_lhsOusedFields [Identifier]
_lhsOusedLocals
         in T_HsTokens_vOut4
__result_ )
     in T_HsTokens_v4 -> T_HsTokens_s5
C_HsTokens_s5 T_HsTokens_v4
v4
   {-# INLINE rule65 #-}
   {-# LINE 119 "src-ag/SemHsTokens.ag" #-}
   rule65 = \  (_ :: ()) ->
                     {-# LINE 119 "src-ag/SemHsTokens.ag" #-}
                     []
                     {-# LINE 562 "src-generated/SemHsTokens.hs" #-}
   {-# INLINE rule66 #-}
   rule66 = \  (_ :: ()) ->
     Seq.empty
   {-# INLINE rule67 #-}
   rule67 = \  (_ :: ()) ->
     []
   {-# INLINE rule68 #-}
   rule68 = \  (_ :: ()) ->
     Seq.empty
   {-# INLINE rule69 #-}
   rule69 = \  (_ :: ()) ->
     []
   {-# INLINE rule70 #-}
   rule70 = \  (_ :: ()) ->
     []
   {-# INLINE rule71 #-}
   rule71 = \ _output ->
     _output

-- HsTokensRoot ------------------------------------------------
-- wrapper
data Inh_HsTokensRoot  = Inh_HsTokensRoot { Inh_HsTokensRoot -> [(Identifier, Type, ChildKind)]
allfields_Inh_HsTokensRoot :: ([(Identifier,Type,ChildKind)]), Inh_HsTokensRoot -> [Identifier]
allnts_Inh_HsTokensRoot :: ([Identifier]), Inh_HsTokensRoot -> [(Identifier, Identifier)]
attrs_Inh_HsTokensRoot :: ([(Identifier,Identifier)]), Inh_HsTokensRoot -> Identifier
con_Inh_HsTokensRoot :: (Identifier), Inh_HsTokensRoot -> Identifier
nt_Inh_HsTokensRoot :: (Identifier), Inh_HsTokensRoot -> Options
options_Inh_HsTokensRoot :: (Options) }
data Syn_HsTokensRoot  = Syn_HsTokensRoot { Syn_HsTokensRoot -> Seq Error
errors_Syn_HsTokensRoot :: (Seq Error), Syn_HsTokensRoot -> HsTokens
output_Syn_HsTokensRoot :: ([HsToken]), Syn_HsTokensRoot -> [String]
textLines_Syn_HsTokensRoot :: ([String]), Syn_HsTokensRoot -> [(Identifier, Identifier)]
usedAttrs_Syn_HsTokensRoot :: ([(Identifier,Identifier)]), Syn_HsTokensRoot -> [Identifier]
usedFields_Syn_HsTokensRoot :: ([Identifier]), Syn_HsTokensRoot -> [Identifier]
usedLocals_Syn_HsTokensRoot :: ([Identifier]) }
{-# INLINABLE wrap_HsTokensRoot #-}
wrap_HsTokensRoot :: T_HsTokensRoot  -> Inh_HsTokensRoot  -> (Syn_HsTokensRoot )
wrap_HsTokensRoot :: T_HsTokensRoot -> Inh_HsTokensRoot -> Syn_HsTokensRoot
wrap_HsTokensRoot (T_HsTokensRoot Identity T_HsTokensRoot_s8
act) (Inh_HsTokensRoot [(Identifier, Type, ChildKind)]
_lhsIallfields [Identifier]
_lhsIallnts [(Identifier, Identifier)]
_lhsIattrs Identifier
_lhsIcon Identifier
_lhsInt Options
_lhsIoptions) =
   forall a. Identity a -> a
Control.Monad.Identity.runIdentity (
     do T_HsTokensRoot_s8
sem <- Identity T_HsTokensRoot_s8
act
        let arg7 :: T_HsTokensRoot_vIn7
arg7 = [(Identifier, Type, ChildKind)]
-> [Identifier]
-> [(Identifier, Identifier)]
-> Identifier
-> Identifier
-> Options
-> T_HsTokensRoot_vIn7
T_HsTokensRoot_vIn7 [(Identifier, Type, ChildKind)]
_lhsIallfields [Identifier]
_lhsIallnts [(Identifier, Identifier)]
_lhsIattrs Identifier
_lhsIcon Identifier
_lhsInt Options
_lhsIoptions
        (T_HsTokensRoot_vOut7 Seq Error
_lhsOerrors HsTokens
_lhsOoutput [String]
_lhsOtextLines [(Identifier, Identifier)]
_lhsOusedAttrs [Identifier]
_lhsOusedFields [Identifier]
_lhsOusedLocals) <- forall (m :: * -> *) a. Monad m => a -> m a
return (T_HsTokensRoot_s8 -> T_HsTokensRoot_v7
inv_HsTokensRoot_s8 T_HsTokensRoot_s8
sem T_HsTokensRoot_vIn7
arg7)
        forall (m :: * -> *) a. Monad m => a -> m a
return (Seq Error
-> HsTokens
-> [String]
-> [(Identifier, Identifier)]
-> [Identifier]
-> [Identifier]
-> Syn_HsTokensRoot
Syn_HsTokensRoot Seq Error
_lhsOerrors HsTokens
_lhsOoutput [String]
_lhsOtextLines [(Identifier, Identifier)]
_lhsOusedAttrs [Identifier]
_lhsOusedFields [Identifier]
_lhsOusedLocals)
   )

-- cata
{-# INLINE sem_HsTokensRoot #-}
sem_HsTokensRoot :: HsTokensRoot  -> T_HsTokensRoot 
sem_HsTokensRoot :: HsTokensRoot -> T_HsTokensRoot
sem_HsTokensRoot ( HsTokensRoot HsTokens
tokens_ ) = T_HsTokens -> T_HsTokensRoot
sem_HsTokensRoot_HsTokensRoot ( HsTokens -> T_HsTokens
sem_HsTokens HsTokens
tokens_ )

-- semantic domain
newtype T_HsTokensRoot  = T_HsTokensRoot {
                                         T_HsTokensRoot -> Identity T_HsTokensRoot_s8
attach_T_HsTokensRoot :: Identity (T_HsTokensRoot_s8 )
                                         }
newtype T_HsTokensRoot_s8  = C_HsTokensRoot_s8 {
                                               T_HsTokensRoot_s8 -> T_HsTokensRoot_v7
inv_HsTokensRoot_s8 :: (T_HsTokensRoot_v7 )
                                               }
data T_HsTokensRoot_s9  = C_HsTokensRoot_s9
type T_HsTokensRoot_v7  = (T_HsTokensRoot_vIn7 ) -> (T_HsTokensRoot_vOut7 )
data T_HsTokensRoot_vIn7  = T_HsTokensRoot_vIn7 ([(Identifier,Type,ChildKind)]) ([Identifier]) ([(Identifier,Identifier)]) (Identifier) (Identifier) (Options)
data T_HsTokensRoot_vOut7  = T_HsTokensRoot_vOut7 (Seq Error) ([HsToken]) ([String]) ([(Identifier,Identifier)]) ([Identifier]) ([Identifier])
{-# NOINLINE sem_HsTokensRoot_HsTokensRoot #-}
sem_HsTokensRoot_HsTokensRoot :: T_HsTokens  -> T_HsTokensRoot 
sem_HsTokensRoot_HsTokensRoot :: T_HsTokens -> T_HsTokensRoot
sem_HsTokensRoot_HsTokensRoot T_HsTokens
arg_tokens_ = Identity T_HsTokensRoot_s8 -> T_HsTokensRoot
T_HsTokensRoot (forall (m :: * -> *) a. Monad m => a -> m a
return T_HsTokensRoot_s8
st8) where
   {-# NOINLINE st8 #-}
   st8 :: T_HsTokensRoot_s8
st8 = let
      v7 :: T_HsTokensRoot_v7 
      v7 :: T_HsTokensRoot_v7
v7 = \ (T_HsTokensRoot_vIn7 [(Identifier, Type, ChildKind)]
_lhsIallfields [Identifier]
_lhsIallnts [(Identifier, Identifier)]
_lhsIattrs Identifier
_lhsIcon Identifier
_lhsInt Options
_lhsIoptions) -> ( let
         _tokensX5 :: T_HsTokens_s5
_tokensX5 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_HsTokens -> Identity T_HsTokens_s5
attach_T_HsTokens (T_HsTokens
arg_tokens_))
         (T_HsTokens_vOut4 Seq Error
_tokensIerrors HsTokens
_tokensIoutput [(Pos, String)]
_tokensItks [(Identifier, Identifier)]
_tokensIusedAttrs Seq Identifier
_tokensIusedFields [Identifier]
_tokensIusedLocals) = T_HsTokens_s5 -> T_HsTokens_v4
inv_HsTokens_s5 T_HsTokens_s5
_tokensX5 ([(Identifier, Type, ChildKind)]
-> [Identifier]
-> [(Identifier, Identifier)]
-> Identifier
-> [Identifier]
-> Identifier
-> Options
-> T_HsTokens_vIn4
T_HsTokens_vIn4 [(Identifier, Type, ChildKind)]
_tokensOallfields [Identifier]
_tokensOallnts [(Identifier, Identifier)]
_tokensOattrs Identifier
_tokensOcon [Identifier]
_tokensOfieldnames Identifier
_tokensOnt Options
_tokensOoptions)
         _tokensOfieldnames :: [Identifier]
_tokensOfieldnames = [(Identifier, Type, ChildKind)] -> [Identifier]
rule72 [(Identifier, Type, ChildKind)]
_lhsIallfields
         _lhsOusedFields :: [Identifier]
         _lhsOusedFields :: [Identifier]
_lhsOusedFields = Seq Identifier -> [Identifier]
rule73 Seq Identifier
_tokensIusedFields
         _lhsOtextLines :: [String]
         _lhsOtextLines :: [String]
_lhsOtextLines = [(Pos, String)] -> [String]
rule74 [(Pos, String)]
_tokensItks
         _lhsOerrors :: Seq Error
         _lhsOerrors :: Seq Error
_lhsOerrors = Seq Error -> Seq Error
rule75 Seq Error
_tokensIerrors
         _lhsOoutput :: [HsToken]
         _lhsOoutput :: HsTokens
_lhsOoutput = HsTokens -> HsTokens
rule76 HsTokens
_tokensIoutput
         _lhsOusedAttrs :: [(Identifier,Identifier)]
         _lhsOusedAttrs :: [(Identifier, Identifier)]
_lhsOusedAttrs = [(Identifier, Identifier)] -> [(Identifier, Identifier)]
rule77 [(Identifier, Identifier)]
_tokensIusedAttrs
         _lhsOusedLocals :: [Identifier]
         _lhsOusedLocals :: [Identifier]
_lhsOusedLocals = [Identifier] -> [Identifier]
rule78 [Identifier]
_tokensIusedLocals
         _tokensOallfields :: [(Identifier, Type, ChildKind)]
_tokensOallfields = [(Identifier, Type, ChildKind)] -> [(Identifier, Type, ChildKind)]
rule79 [(Identifier, Type, ChildKind)]
_lhsIallfields
         _tokensOallnts :: [Identifier]
_tokensOallnts = [Identifier] -> [Identifier]
rule80 [Identifier]
_lhsIallnts
         _tokensOattrs :: [(Identifier, Identifier)]
_tokensOattrs = [(Identifier, Identifier)] -> [(Identifier, Identifier)]
rule81 [(Identifier, Identifier)]
_lhsIattrs
         _tokensOcon :: Identifier
_tokensOcon = Identifier -> Identifier
rule82 Identifier
_lhsIcon
         _tokensOnt :: Identifier
_tokensOnt = Identifier -> Identifier
rule83 Identifier
_lhsInt
         _tokensOoptions :: Options
_tokensOoptions = Options -> Options
rule84 Options
_lhsIoptions
         __result_ :: T_HsTokensRoot_vOut7
__result_ = Seq Error
-> HsTokens
-> [String]
-> [(Identifier, Identifier)]
-> [Identifier]
-> [Identifier]
-> T_HsTokensRoot_vOut7
T_HsTokensRoot_vOut7 Seq Error
_lhsOerrors HsTokens
_lhsOoutput [String]
_lhsOtextLines [(Identifier, Identifier)]
_lhsOusedAttrs [Identifier]
_lhsOusedFields [Identifier]
_lhsOusedLocals
         in T_HsTokensRoot_vOut7
__result_ )
     in T_HsTokensRoot_v7 -> T_HsTokensRoot_s8
C_HsTokensRoot_s8 T_HsTokensRoot_v7
v7
   {-# INLINE rule72 #-}
   {-# LINE 39 "src-ag/SemHsTokens.ag" #-}
   rule72 = \ ((_lhsIallfields) :: [(Identifier,Type,ChildKind)]) ->
                                       {-# LINE 39 "src-ag/SemHsTokens.ag" #-}
                                       map (\(n,_,_) -> n) _lhsIallfields
                                       {-# LINE 648 "src-generated/SemHsTokens.hs" #-}
   {-# INLINE rule73 #-}
   {-# LINE 108 "src-ag/SemHsTokens.ag" #-}
   rule73 = \ ((_tokensIusedFields) :: Seq Identifier) ->
                                    {-# LINE 108 "src-ag/SemHsTokens.ag" #-}
                                    toList _tokensIusedFields
                                    {-# LINE 654 "src-generated/SemHsTokens.hs" #-}
   {-# INLINE rule74 #-}
   {-# LINE 115 "src-ag/SemHsTokens.ag" #-}
   rule74 = \ ((_tokensItks) :: [(Pos,String)]) ->
                                   {-# LINE 115 "src-ag/SemHsTokens.ag" #-}
                                   showTokens _tokensItks
                                   {-# LINE 660 "src-generated/SemHsTokens.hs" #-}
   {-# INLINE rule75 #-}
   rule75 = \ ((_tokensIerrors) :: Seq Error) ->
     _tokensIerrors
   {-# INLINE rule76 #-}
   rule76 = \ ((_tokensIoutput) :: HsTokens) ->
     _tokensIoutput
   {-# INLINE rule77 #-}
   rule77 = \ ((_tokensIusedAttrs) :: [(Identifier,Identifier)]) ->
     _tokensIusedAttrs
   {-# INLINE rule78 #-}
   rule78 = \ ((_tokensIusedLocals) :: [Identifier]) ->
     _tokensIusedLocals
   {-# INLINE rule79 #-}
   rule79 = \ ((_lhsIallfields) :: [(Identifier,Type,ChildKind)]) ->
     _lhsIallfields
   {-# INLINE rule80 #-}
   rule80 = \ ((_lhsIallnts) :: [Identifier]) ->
     _lhsIallnts
   {-# INLINE rule81 #-}
   rule81 = \ ((_lhsIattrs) :: [(Identifier,Identifier)]) ->
     _lhsIattrs
   {-# INLINE rule82 #-}
   rule82 = \ ((_lhsIcon) :: Identifier) ->
     _lhsIcon
   {-# INLINE rule83 #-}
   rule83 = \ ((_lhsInt) :: Identifier) ->
     _lhsInt
   {-# INLINE rule84 #-}
   rule84 = \ ((_lhsIoptions) :: Options) ->
     _lhsIoptions