{-# LANGUAGE Rank2Types, GADTs #-} {-# LANGUAGE ScopedTypeVariables #-} module Order where {-# LINE 2 "./src-ag/Patterns.ag" #-} -- Patterns.ag imports import UU.Scanner.Position(Pos) import CommonTypes (ConstructorIdent,Identifier) {-# LINE 11 "dist/build/Order.hs" #-} {-# LINE 2 "./src-ag/Expression.ag" #-} import UU.Scanner.Position(Pos) import HsToken {-# LINE 17 "dist/build/Order.hs" #-} {-# LINE 2 "./src-ag/AbstractSyntax.ag" #-} -- AbstractSyntax.ag imports import Data.Set(Set) import Data.Map(Map) import Patterns (Pattern(..),Patterns) import Expression (Expression(..)) import Macro --marcos import CommonTypes import ErrorMessages {-# LINE 29 "dist/build/Order.hs" #-} {-# LINE 10 "./src-ag/Order.ag" #-} -- From uuagc import CommonTypes import Patterns import ErrorMessages import AbstractSyntax import Code hiding (Type) import qualified Code import Expression import Options import SequentialComputation import SequentialTypes import CodeSyntax import GrammarInfo import HsToken(HsTokensRoot(HsTokensRoot)) import HsTokenScanner(lexTokens) import SemHsTokens(sem_HsTokensRoot,wrap_HsTokensRoot, Syn_HsTokensRoot(..),Inh_HsTokensRoot(..)) -- From uulib import qualified Data.Map as Map import qualified Data.Set as Set import qualified Data.Sequence as Seq import Data.Map(Map) import Data.Set(Set) import Data.Sequence(Seq, (><)) import UU.Util.Utils import UU.Scanner.Position(Pos(..),initPos) import Data.Foldable(toList) -- From haskell libraries import Control.Monad(liftM) import qualified Data.Array as Array import Data.Array((!),bounds,inRange) import Data.List(elemIndex,partition,sort,mapAccumL,find,nubBy,intersperse,groupBy,transpose) import qualified Data.Tree as Tree import Data.Maybe {-# LINE 67 "dist/build/Order.hs" #-} import Control.Monad.Identity (Identity) import qualified Control.Monad.Identity {-# LINE 47 "./src-ag/Order.ag" #-} -- Terminates with an error if the key is not in the map findWithErr1 :: (Ord k, Show k) => String -> k -> Map k a -> a findWithErr1 s k = Map.findWithDefault (error ("findWithErr1 " ++ s ++ ": key " ++ show k ++ " not in map.")) k findWithErr2 :: (Ord k, Show k, Show a) => k -> Map k a -> a findWithErr2 k m = Map.findWithDefault (error ("findWithErr2: key " ++ show k ++ " not in map: " ++ show m)) k m {-# LINE 80 "dist/build/Order.hs" #-} {-# LINE 72 "./src-ag/Order.ag" #-} startsWith :: String -> String -> Bool startsWith k h = k == take (length k) h {-# LINE 86 "dist/build/Order.hs" #-} {-# LINE 139 "./src-ag/Order.ag" #-} getNtName :: Type -> NontermIdent getNtName (NT nt _ _) = nt getNtName _ = nullIdent {-# LINE 93 "dist/build/Order.hs" #-} {-# LINE 167 "./src-ag/Order.ag" #-} data AltAttr = AltAttr Identifier Identifier Bool deriving (Eq, Ord, Show) {-# LINE 99 "dist/build/Order.hs" #-} {-# LINE 237 "./src-ag/Order.ag" #-} substSelf nt tp = case tp of NT n tps defor | n == _SELF -> NT nt tps defor _ -> tp haskellTupel :: [Type] -> Maybe Type haskellTupel ts = Just ( Haskell ( '(' : (concat (intersperse "," (map show ts))) ++ ")" )) {-# LINE 110 "dist/build/Order.hs" #-} {-# LINE 688 "./src-ag/Order.ag" #-} swap (a,b) = (b,a) showPath :: Table CRule -> [Vertex] -> [String] showPath ruleTable path = let look a | inRange (bounds ruleTable) a = [showOrigin (ruleTable ! a)] | otherwise = ["Vertex " ++ show a] showOrigin cr | getHasCode cr && getName (getAttr cr) /= "self" = prettyCRule cr ++ " (" ++ show (getPos (getAttr cr)) ++ ")" | otherwise = prettyCRule cr in concatMap look path showPathLocal :: Table CRule -> [Vertex] -> [String] showPathLocal _ [] = [] showPathLocal ruleTable xs = showP (xs++[-1]) where showP [] = [] showP (v1:v2:vs) = let line = step v1 v2 lines = showP vs in line:lines step v1 v2 = " - " ++ a1 where r1 = ruleTable ! v1 a1 = show (getAttr r1) limitTo :: Int -> [String] -> [String] limitTo _ [] = [] limitTo 0 _ = ["....etcetera, etcetera...."] limitTo n (x:xs) = x : limitTo (n-1) xs showPathNice :: Table CRule -> [Vertex] -> [String] showPathNice _ [] = [] showPathNice ruleTable xs = limitTo 100 (showP ((-1):xs++[-1])) where [maxf, maxa, maxn, maxc] = maxWidths ruleTable (take 100 xs) showP [] = [] showP (v1:v2:vs) = let line = step v1 v2 lines = showP vs in if null line then lines else line:lines step v1 v2 | last && first = induced | last && isSyn r1 = "pass up " ++ alignR maxf "" ++ " " ++ alignL maxa a1 ++ " in " ++ alignR maxn n1 ++ "|" ++ c1 ++ induced | first&& not(isSyn r2) = "get from above " ++ alignR maxf "" ++ " " ++ alignL maxa a2 ++ " in " ++ alignR maxn n2 ++ "|" ++ c2 | last = "pass down " ++ alignR maxf f1 ++ "." ++ a1 ++ induced | isSyn r2 = "get from below " ++ alignR maxf f2 ++ "." ++ alignL maxa a2 ++ " in " ++ alignR maxn n2 ++ "|" ++ c2 | isLocal r1 = if head a1 == '_' then "" else "calculate " ++ alignR maxf "loc" ++ "." ++ a1 | otherwise = "pass down " ++ alignR maxf f1 ++ "." ++ alignL maxa a1 ++ " to " ++ alignR maxn n2 ++ "|" ++ c2 where first = v1<0 last = v2<0 r1 = ruleTable ! v1 r2 = ruleTable ! v2 a1 = show (getAttr r1) a2 = show (getAttr r2) f1 = show (getField r1) f2 = show (getField r2) n1 = show (getLhsNt r1) n2 = show (getLhsNt r2) c1 = show (getCon r1) c2 = show (getCon r2) induced | v2== -2 = " INDUCED dependency to " | otherwise = "" maxWidths ruleTable vs = map maximum (transpose (map getWidth vs)) where getWidth v | v<0 = [0,0,0,0] | otherwise = map (length . show . ($ (ruleTable!v))) [getField, getAttr, getLhsNt, getCon] alignL n xs | k Bool -> Route -> Error localCycleErr ruleTable o_visit (s:path) = let cr = ruleTable ! s attr = getAttr cr nt = getLhsNt cr con = getCon cr in LocalCirc nt con attr o_visit (showPathLocal ruleTable path) instCycleErr :: Table CRule -> Bool -> Route -> Error instCycleErr ruleTable o_visit (s:path) = let cr = ruleTable ! s attr = getAttr cr nt = getLhsNt cr con = getCon cr in InstCirc nt con attr o_visit (showPathLocal ruleTable path) directCycleErrs :: Table NTAttr -> Table CRule -> Bool -> [EdgeRoutes] -> [Error] directCycleErrs attrTable ruleTable o_visit xs = let getNont v = case attrTable ! v of NTASyn nt _ _ -> nt NTAInh nt _ _ -> nt getAttr v = case attrTable ! v of NTASyn _ a _ -> a NTAInh _ a _ -> a sameNont ((v1,_),_,_) ((v2,_),_,_) = getNont v1 == getNont v2 procCycle ((v1,v2),p1,p2) = ((getAttr v1, getAttr v2), showPathNice ruleTable p1, showPathNice ruleTable p2) wrapGroup gr@(((v1,_),_,_):_) = DirectCirc (getNont v1) o_visit (map procCycle gr) in map wrapGroup (groupBy sameNont xs) inducedCycleErrs :: Table NTAttr -> Table CRule -> CInterfaceMap -> [EdgeRoutes] -> [Error] inducedCycleErrs attrTable ruleTable cim xs = let getNont v = case attrTable ! v of NTASyn nt _ _ -> nt NTAInh nt _ _ -> nt getAttr v = case attrTable ! v of NTASyn _ a _ -> a NTAInh _ a _ -> a sameNont ((v1,_),_,_) ((v2,_),_,_) = getNont v1 == getNont v2 procCycle ((v1,v2),p1,p2) = ((getAttr v1, getAttr v2), showPathNice ruleTable p1, showPathNice ruleTable p2) wrapGroup gr@(((v1,_),_,_):_) = InducedCirc (getNont v1) (findWithErr1 "inducedCycleErr.cinter" (getNont v1) cim) (map procCycle gr) in map wrapGroup (groupBy sameNont xs) {-# LINE 230 "dist/build/Order.hs" #-} -- Child ------------------------------------------------------- -- wrapper data Inh_Child = Inh_Child { allfields_Inh_Child :: ([(Identifier,Type,ChildKind)]), allnts_Inh_Child :: ([Identifier]), attrs_Inh_Child :: ([(Identifier,Identifier)]), con_Inh_Child :: (Identifier), inh_Inh_Child :: (Attributes), inhMap_Inh_Child :: (Map Identifier Attributes), mergeMap_Inh_Child :: (Map Identifier (Identifier,[Identifier])), nt_Inh_Child :: (Identifier), o_unbox_Inh_Child :: (Bool), syn_Inh_Child :: (Attributes), synMap_Inh_Child :: (Map Identifier Attributes) } data Syn_Child = Syn_Child { attributes_Syn_Child :: ([(Identifier,Attributes,Attributes)]), collectChildrenInhs_Syn_Child :: (Map Identifier Attributes ), collectChildrenSyns_Syn_Child :: (Map Identifier Attributes ), errors_Syn_Child :: (Seq Error), field_Syn_Child :: ((Identifier,Type,ChildKind)), gathAltAttrs_Syn_Child :: ([AltAttr]), gathRules_Syn_Child :: (Seq CRule), inhs_Syn_Child :: (Seq (Identifier,Attributes)), nts_Syn_Child :: (Seq (Identifier,NontermIdent)), singlevisits_Syn_Child :: ([CRule]), terminals_Syn_Child :: ([Identifier]) } {-# INLINABLE wrap_Child #-} wrap_Child :: T_Child -> Inh_Child -> (Syn_Child ) wrap_Child (T_Child act) (Inh_Child _lhsIallfields _lhsIallnts _lhsIattrs _lhsIcon _lhsIinh _lhsIinhMap _lhsImergeMap _lhsInt _lhsIo_unbox _lhsIsyn _lhsIsynMap) = Control.Monad.Identity.runIdentity ( do sem <- act let arg = T_Child_vIn1 _lhsIallfields _lhsIallnts _lhsIattrs _lhsIcon _lhsIinh _lhsIinhMap _lhsImergeMap _lhsInt _lhsIo_unbox _lhsIsyn _lhsIsynMap (T_Child_vOut1 _lhsOattributes _lhsOcollectChildrenInhs _lhsOcollectChildrenSyns _lhsOerrors _lhsOfield _lhsOgathAltAttrs _lhsOgathRules _lhsOinhs _lhsOnts _lhsOsinglevisits _lhsOterminals) <- return (inv_Child_s2 sem arg) return (Syn_Child _lhsOattributes _lhsOcollectChildrenInhs _lhsOcollectChildrenSyns _lhsOerrors _lhsOfield _lhsOgathAltAttrs _lhsOgathRules _lhsOinhs _lhsOnts _lhsOsinglevisits _lhsOterminals) ) -- cata {-# INLINE sem_Child #-} sem_Child :: Child -> T_Child sem_Child ( Child name_ tp_ kind_ ) = sem_Child_Child name_ tp_ kind_ -- semantic domain newtype T_Child = T_Child { attach_T_Child :: Identity (T_Child_s2 ) } newtype T_Child_s2 = C_Child_s2 { inv_Child_s2 :: (T_Child_v1 ) } data T_Child_s3 = C_Child_s3 type T_Child_v1 = (T_Child_vIn1 ) -> (T_Child_vOut1 ) data T_Child_vIn1 = T_Child_vIn1 ([(Identifier,Type,ChildKind)]) ([Identifier]) ([(Identifier,Identifier)]) (Identifier) (Attributes) (Map Identifier Attributes) (Map Identifier (Identifier,[Identifier])) (Identifier) (Bool) (Attributes) (Map Identifier Attributes) data T_Child_vOut1 = T_Child_vOut1 ([(Identifier,Attributes,Attributes)]) (Map Identifier Attributes ) (Map Identifier Attributes ) (Seq Error) ((Identifier,Type,ChildKind)) ([AltAttr]) (Seq CRule) (Seq (Identifier,Attributes)) (Seq (Identifier,NontermIdent)) ([CRule]) ([Identifier]) {-# NOINLINE sem_Child_Child #-} sem_Child_Child :: (Identifier) -> (Type) -> (ChildKind) -> T_Child sem_Child_Child arg_name_ arg_tp_ arg_kind_ = T_Child (return st2) where {-# NOINLINE st2 #-} st2 = let v1 :: T_Child_v1 v1 = \ (T_Child_vIn1 _lhsIallfields _lhsIallnts _lhsIattrs _lhsIcon _lhsIinh _lhsIinhMap _lhsImergeMap _lhsInt _lhsIo_unbox _lhsIsyn _lhsIsynMap) -> ( let _chnt = rule0 arg_name_ arg_tp_ _inh = rule1 _chnt _lhsIinhMap _syn = rule2 _chnt _lhsIsynMap _maptolocal = rule3 _syn arg_tp_ _lhsOgathAltAttrs :: [AltAttr] _lhsOgathAltAttrs = rule4 _maptolocal _syn arg_name_ _lhsOnts :: Seq (Identifier,NontermIdent) _lhsOnts = rule5 arg_name_ arg_tp_ _lhsOinhs :: Seq (Identifier,Attributes) _lhsOinhs = rule6 _inh arg_name_ _gathRules = rule7 _lhsIcon _lhsInt _maptolocal _syn arg_name_ arg_tp_ _lhsOcollectChildrenSyns :: Map Identifier Attributes _lhsOcollectChildrenSyns = rule8 _syn arg_name_ _lhsOcollectChildrenInhs :: Map Identifier Attributes _lhsOcollectChildrenInhs = rule9 _inh arg_name_ _lhsOsinglevisits :: [CRule] _lhsOsinglevisits = rule10 _inh _maptolocal _syn arg_name_ arg_tp_ _lhsOterminals :: [Identifier] _lhsOterminals = rule11 _maptolocal arg_name_ _lhsOattributes :: [(Identifier,Attributes,Attributes)] _lhsOattributes = rule12 _inh _syn arg_name_ _lhsOfield :: (Identifier,Type,ChildKind) _lhsOfield = rule13 arg_kind_ arg_name_ arg_tp_ _lhsOerrors :: Seq Error _lhsOerrors = rule14 () _lhsOgathRules :: Seq CRule _lhsOgathRules = rule15 _gathRules __result_ = T_Child_vOut1 _lhsOattributes _lhsOcollectChildrenInhs _lhsOcollectChildrenSyns _lhsOerrors _lhsOfield _lhsOgathAltAttrs _lhsOgathRules _lhsOinhs _lhsOnts _lhsOsinglevisits _lhsOterminals in __result_ ) in C_Child_s2 v1 {-# INLINE rule0 #-} {-# LINE 19 "./src-ag/DistChildAttr.ag" #-} rule0 = \ name_ tp_ -> {-# LINE 19 "./src-ag/DistChildAttr.ag" #-} case tp_ of NT nt _ _ -> nt Self -> error ("The type of child " ++ show name_ ++ " should not be a Self type.") Haskell t -> identifier "" {-# LINE 306 "dist/build/Order.hs"#-} {-# INLINE rule1 #-} {-# LINE 23 "./src-ag/DistChildAttr.ag" #-} rule1 = \ _chnt ((_lhsIinhMap) :: Map Identifier Attributes) -> {-# LINE 23 "./src-ag/DistChildAttr.ag" #-} Map.findWithDefault Map.empty _chnt _lhsIinhMap {-# LINE 312 "dist/build/Order.hs"#-} {-# INLINE rule2 #-} {-# LINE 24 "./src-ag/DistChildAttr.ag" #-} rule2 = \ _chnt ((_lhsIsynMap) :: Map Identifier Attributes) -> {-# LINE 24 "./src-ag/DistChildAttr.ag" #-} Map.findWithDefault Map.empty _chnt _lhsIsynMap {-# LINE 318 "dist/build/Order.hs"#-} {-# INLINE rule3 #-} {-# LINE 178 "./src-ag/Order.ag" #-} rule3 = \ _syn tp_ -> {-# LINE 178 "./src-ag/Order.ag" #-} case tp_ of NT nt _ _ -> Map.null _syn _ -> True {-# LINE 326 "dist/build/Order.hs"#-} {-# INLINE rule4 #-} {-# LINE 181 "./src-ag/Order.ag" #-} rule4 = \ _maptolocal _syn name_ -> {-# LINE 181 "./src-ag/Order.ag" #-} if _maptolocal then [ AltAttr _LOC name_ True ] else [ AltAttr name_ syn True | syn <- Map.keys _syn ] {-# LINE 334 "dist/build/Order.hs"#-} {-# INLINE rule5 #-} {-# LINE 196 "./src-ag/Order.ag" #-} rule5 = \ name_ tp_ -> {-# LINE 196 "./src-ag/Order.ag" #-} Seq.singleton (name_,getNtName tp_) {-# LINE 340 "dist/build/Order.hs"#-} {-# INLINE rule6 #-} {-# LINE 197 "./src-ag/Order.ag" #-} rule6 = \ _inh name_ -> {-# LINE 197 "./src-ag/Order.ag" #-} Seq.singleton (name_,_inh ) {-# LINE 346 "dist/build/Order.hs"#-} {-# INLINE rule7 #-} {-# LINE 213 "./src-ag/Order.ag" #-} rule7 = \ ((_lhsIcon) :: Identifier) ((_lhsInt) :: Identifier) _maptolocal _syn name_ tp_ -> {-# LINE 213 "./src-ag/Order.ag" #-} if _maptolocal then Seq.singleton (cRuleTerminal name_ _lhsInt _lhsIcon tp_) else Seq.fromList [ cRuleRhsSyn syn _lhsInt _lhsIcon tp name_ (getNtName tp_) | (syn,tp) <- Map.assocs _syn ] {-# LINE 354 "dist/build/Order.hs"#-} {-# INLINE rule8 #-} {-# LINE 345 "./src-ag/Order.ag" #-} rule8 = \ _syn name_ -> {-# LINE 345 "./src-ag/Order.ag" #-} Map.singleton name_ _syn {-# LINE 360 "dist/build/Order.hs"#-} {-# INLINE rule9 #-} {-# LINE 346 "./src-ag/Order.ag" #-} rule9 = \ _inh name_ -> {-# LINE 346 "./src-ag/Order.ag" #-} Map.singleton name_ _inh {-# LINE 366 "dist/build/Order.hs"#-} {-# INLINE rule10 #-} {-# LINE 614 "./src-ag/Order.ag" #-} rule10 = \ _inh _maptolocal _syn name_ tp_ -> {-# LINE 614 "./src-ag/Order.ag" #-} if _maptolocal then [] else [CChildVisit name_ (getNtName tp_) 0 _inh _syn True] {-# LINE 374 "dist/build/Order.hs"#-} {-# INLINE rule11 #-} {-# LINE 639 "./src-ag/Order.ag" #-} rule11 = \ _maptolocal name_ -> {-# LINE 639 "./src-ag/Order.ag" #-} if _maptolocal then [name_] else [] {-# LINE 382 "dist/build/Order.hs"#-} {-# INLINE rule12 #-} {-# LINE 668 "./src-ag/Order.ag" #-} rule12 = \ _inh _syn name_ -> {-# LINE 668 "./src-ag/Order.ag" #-} [(name_, _inh , _syn )] {-# LINE 388 "dist/build/Order.hs"#-} {-# INLINE rule13 #-} {-# LINE 672 "./src-ag/Order.ag" #-} rule13 = \ kind_ name_ tp_ -> {-# LINE 672 "./src-ag/Order.ag" #-} (name_, tp_, kind_) {-# LINE 394 "dist/build/Order.hs"#-} {-# INLINE rule14 #-} rule14 = \ (_ :: ()) -> Seq.empty {-# INLINE rule15 #-} rule15 = \ _gathRules -> _gathRules -- Children ---------------------------------------------------- -- wrapper data Inh_Children = Inh_Children { allfields_Inh_Children :: ([(Identifier,Type,ChildKind)]), allnts_Inh_Children :: ([Identifier]), attrs_Inh_Children :: ([(Identifier,Identifier)]), con_Inh_Children :: (Identifier), inh_Inh_Children :: (Attributes), inhMap_Inh_Children :: (Map Identifier Attributes), mergeMap_Inh_Children :: (Map Identifier (Identifier,[Identifier])), nt_Inh_Children :: (Identifier), o_unbox_Inh_Children :: (Bool), syn_Inh_Children :: (Attributes), synMap_Inh_Children :: (Map Identifier Attributes) } data Syn_Children = Syn_Children { attributes_Syn_Children :: ([(Identifier,Attributes,Attributes)]), collectChildrenInhs_Syn_Children :: (Map Identifier Attributes ), collectChildrenSyns_Syn_Children :: (Map Identifier Attributes ), errors_Syn_Children :: (Seq Error), fields_Syn_Children :: ([(Identifier,Type,ChildKind)]), gathAltAttrs_Syn_Children :: ([AltAttr]), gathRules_Syn_Children :: (Seq CRule), inhs_Syn_Children :: (Seq (Identifier,Attributes)), nts_Syn_Children :: (Seq (Identifier,NontermIdent)), singlevisits_Syn_Children :: ([CRule]), terminals_Syn_Children :: ([Identifier]) } {-# INLINABLE wrap_Children #-} wrap_Children :: T_Children -> Inh_Children -> (Syn_Children ) wrap_Children (T_Children act) (Inh_Children _lhsIallfields _lhsIallnts _lhsIattrs _lhsIcon _lhsIinh _lhsIinhMap _lhsImergeMap _lhsInt _lhsIo_unbox _lhsIsyn _lhsIsynMap) = Control.Monad.Identity.runIdentity ( do sem <- act let arg = T_Children_vIn4 _lhsIallfields _lhsIallnts _lhsIattrs _lhsIcon _lhsIinh _lhsIinhMap _lhsImergeMap _lhsInt _lhsIo_unbox _lhsIsyn _lhsIsynMap (T_Children_vOut4 _lhsOattributes _lhsOcollectChildrenInhs _lhsOcollectChildrenSyns _lhsOerrors _lhsOfields _lhsOgathAltAttrs _lhsOgathRules _lhsOinhs _lhsOnts _lhsOsinglevisits _lhsOterminals) <- return (inv_Children_s5 sem arg) return (Syn_Children _lhsOattributes _lhsOcollectChildrenInhs _lhsOcollectChildrenSyns _lhsOerrors _lhsOfields _lhsOgathAltAttrs _lhsOgathRules _lhsOinhs _lhsOnts _lhsOsinglevisits _lhsOterminals) ) -- cata {-# NOINLINE sem_Children #-} sem_Children :: Children -> T_Children sem_Children list = Prelude.foldr sem_Children_Cons sem_Children_Nil (Prelude.map sem_Child list) -- semantic domain newtype T_Children = T_Children { attach_T_Children :: Identity (T_Children_s5 ) } newtype T_Children_s5 = C_Children_s5 { inv_Children_s5 :: (T_Children_v4 ) } data T_Children_s6 = C_Children_s6 type T_Children_v4 = (T_Children_vIn4 ) -> (T_Children_vOut4 ) data T_Children_vIn4 = T_Children_vIn4 ([(Identifier,Type,ChildKind)]) ([Identifier]) ([(Identifier,Identifier)]) (Identifier) (Attributes) (Map Identifier Attributes) (Map Identifier (Identifier,[Identifier])) (Identifier) (Bool) (Attributes) (Map Identifier Attributes) data T_Children_vOut4 = T_Children_vOut4 ([(Identifier,Attributes,Attributes)]) (Map Identifier Attributes ) (Map Identifier Attributes ) (Seq Error) ([(Identifier,Type,ChildKind)]) ([AltAttr]) (Seq CRule) (Seq (Identifier,Attributes)) (Seq (Identifier,NontermIdent)) ([CRule]) ([Identifier]) {-# NOINLINE sem_Children_Cons #-} sem_Children_Cons :: T_Child -> T_Children -> T_Children sem_Children_Cons arg_hd_ arg_tl_ = T_Children (return st5) where {-# NOINLINE st5 #-} st5 = let v4 :: T_Children_v4 v4 = \ (T_Children_vIn4 _lhsIallfields _lhsIallnts _lhsIattrs _lhsIcon _lhsIinh _lhsIinhMap _lhsImergeMap _lhsInt _lhsIo_unbox _lhsIsyn _lhsIsynMap) -> ( let _hdX2 = Control.Monad.Identity.runIdentity (attach_T_Child (arg_hd_)) _tlX5 = Control.Monad.Identity.runIdentity (attach_T_Children (arg_tl_)) (T_Child_vOut1 _hdIattributes _hdIcollectChildrenInhs _hdIcollectChildrenSyns _hdIerrors _hdIfield _hdIgathAltAttrs _hdIgathRules _hdIinhs _hdInts _hdIsinglevisits _hdIterminals) = inv_Child_s2 _hdX2 (T_Child_vIn1 _hdOallfields _hdOallnts _hdOattrs _hdOcon _hdOinh _hdOinhMap _hdOmergeMap _hdOnt _hdOo_unbox _hdOsyn _hdOsynMap) (T_Children_vOut4 _tlIattributes _tlIcollectChildrenInhs _tlIcollectChildrenSyns _tlIerrors _tlIfields _tlIgathAltAttrs _tlIgathRules _tlIinhs _tlInts _tlIsinglevisits _tlIterminals) = inv_Children_s5 _tlX5 (T_Children_vIn4 _tlOallfields _tlOallnts _tlOattrs _tlOcon _tlOinh _tlOinhMap _tlOmergeMap _tlOnt _tlOo_unbox _tlOsyn _tlOsynMap) _lhsOfields :: [(Identifier,Type,ChildKind)] _lhsOfields = rule16 _hdIfield _tlIfields _lhsOattributes :: [(Identifier,Attributes,Attributes)] _lhsOattributes = rule17 _hdIattributes _tlIattributes _lhsOcollectChildrenInhs :: Map Identifier Attributes _lhsOcollectChildrenInhs = rule18 _hdIcollectChildrenInhs _tlIcollectChildrenInhs _lhsOcollectChildrenSyns :: Map Identifier Attributes _lhsOcollectChildrenSyns = rule19 _hdIcollectChildrenSyns _tlIcollectChildrenSyns _lhsOerrors :: Seq Error _lhsOerrors = rule20 _hdIerrors _tlIerrors _lhsOgathAltAttrs :: [AltAttr] _lhsOgathAltAttrs = rule21 _hdIgathAltAttrs _tlIgathAltAttrs _lhsOgathRules :: Seq CRule _lhsOgathRules = rule22 _hdIgathRules _tlIgathRules _lhsOinhs :: Seq (Identifier,Attributes) _lhsOinhs = rule23 _hdIinhs _tlIinhs _lhsOnts :: Seq (Identifier,NontermIdent) _lhsOnts = rule24 _hdInts _tlInts _lhsOsinglevisits :: [CRule] _lhsOsinglevisits = rule25 _hdIsinglevisits _tlIsinglevisits _lhsOterminals :: [Identifier] _lhsOterminals = rule26 _hdIterminals _tlIterminals _hdOallfields = rule27 _lhsIallfields _hdOallnts = rule28 _lhsIallnts _hdOattrs = rule29 _lhsIattrs _hdOcon = rule30 _lhsIcon _hdOinh = rule31 _lhsIinh _hdOinhMap = rule32 _lhsIinhMap _hdOmergeMap = rule33 _lhsImergeMap _hdOnt = rule34 _lhsInt _hdOo_unbox = rule35 _lhsIo_unbox _hdOsyn = rule36 _lhsIsyn _hdOsynMap = rule37 _lhsIsynMap _tlOallfields = rule38 _lhsIallfields _tlOallnts = rule39 _lhsIallnts _tlOattrs = rule40 _lhsIattrs _tlOcon = rule41 _lhsIcon _tlOinh = rule42 _lhsIinh _tlOinhMap = rule43 _lhsIinhMap _tlOmergeMap = rule44 _lhsImergeMap _tlOnt = rule45 _lhsInt _tlOo_unbox = rule46 _lhsIo_unbox _tlOsyn = rule47 _lhsIsyn _tlOsynMap = rule48 _lhsIsynMap __result_ = T_Children_vOut4 _lhsOattributes _lhsOcollectChildrenInhs _lhsOcollectChildrenSyns _lhsOerrors _lhsOfields _lhsOgathAltAttrs _lhsOgathRules _lhsOinhs _lhsOnts _lhsOsinglevisits _lhsOterminals in __result_ ) in C_Children_s5 v4 {-# INLINE rule16 #-} {-# LINE 675 "./src-ag/Order.ag" #-} rule16 = \ ((_hdIfield) :: (Identifier,Type,ChildKind)) ((_tlIfields) :: [(Identifier,Type,ChildKind)]) -> {-# LINE 675 "./src-ag/Order.ag" #-} _hdIfield : _tlIfields {-# LINE 495 "dist/build/Order.hs"#-} {-# INLINE rule17 #-} rule17 = \ ((_hdIattributes) :: [(Identifier,Attributes,Attributes)]) ((_tlIattributes) :: [(Identifier,Attributes,Attributes)]) -> _hdIattributes ++ _tlIattributes {-# INLINE rule18 #-} rule18 = \ ((_hdIcollectChildrenInhs) :: Map Identifier Attributes ) ((_tlIcollectChildrenInhs) :: Map Identifier Attributes ) -> _hdIcollectChildrenInhs `Map.union` _tlIcollectChildrenInhs {-# INLINE rule19 #-} rule19 = \ ((_hdIcollectChildrenSyns) :: Map Identifier Attributes ) ((_tlIcollectChildrenSyns) :: Map Identifier Attributes ) -> _hdIcollectChildrenSyns `Map.union` _tlIcollectChildrenSyns {-# INLINE rule20 #-} rule20 = \ ((_hdIerrors) :: Seq Error) ((_tlIerrors) :: Seq Error) -> _hdIerrors Seq.>< _tlIerrors {-# INLINE rule21 #-} rule21 = \ ((_hdIgathAltAttrs) :: [AltAttr]) ((_tlIgathAltAttrs) :: [AltAttr]) -> _hdIgathAltAttrs ++ _tlIgathAltAttrs {-# INLINE rule22 #-} rule22 = \ ((_hdIgathRules) :: Seq CRule) ((_tlIgathRules) :: Seq CRule) -> _hdIgathRules Seq.>< _tlIgathRules {-# INLINE rule23 #-} rule23 = \ ((_hdIinhs) :: Seq (Identifier,Attributes)) ((_tlIinhs) :: Seq (Identifier,Attributes)) -> _hdIinhs Seq.>< _tlIinhs {-# INLINE rule24 #-} rule24 = \ ((_hdInts) :: Seq (Identifier,NontermIdent)) ((_tlInts) :: Seq (Identifier,NontermIdent)) -> _hdInts Seq.>< _tlInts {-# INLINE rule25 #-} rule25 = \ ((_hdIsinglevisits) :: [CRule]) ((_tlIsinglevisits) :: [CRule]) -> _hdIsinglevisits ++ _tlIsinglevisits {-# INLINE rule26 #-} rule26 = \ ((_hdIterminals) :: [Identifier]) ((_tlIterminals) :: [Identifier]) -> _hdIterminals ++ _tlIterminals {-# INLINE rule27 #-} rule27 = \ ((_lhsIallfields) :: [(Identifier,Type,ChildKind)]) -> _lhsIallfields {-# INLINE rule28 #-} rule28 = \ ((_lhsIallnts) :: [Identifier]) -> _lhsIallnts {-# INLINE rule29 #-} rule29 = \ ((_lhsIattrs) :: [(Identifier,Identifier)]) -> _lhsIattrs {-# INLINE rule30 #-} rule30 = \ ((_lhsIcon) :: Identifier) -> _lhsIcon {-# INLINE rule31 #-} rule31 = \ ((_lhsIinh) :: Attributes) -> _lhsIinh {-# INLINE rule32 #-} rule32 = \ ((_lhsIinhMap) :: Map Identifier Attributes) -> _lhsIinhMap {-# INLINE rule33 #-} rule33 = \ ((_lhsImergeMap) :: Map Identifier (Identifier,[Identifier])) -> _lhsImergeMap {-# INLINE rule34 #-} rule34 = \ ((_lhsInt) :: Identifier) -> _lhsInt {-# INLINE rule35 #-} rule35 = \ ((_lhsIo_unbox) :: Bool) -> _lhsIo_unbox {-# INLINE rule36 #-} rule36 = \ ((_lhsIsyn) :: Attributes) -> _lhsIsyn {-# INLINE rule37 #-} rule37 = \ ((_lhsIsynMap) :: Map Identifier Attributes) -> _lhsIsynMap {-# INLINE rule38 #-} rule38 = \ ((_lhsIallfields) :: [(Identifier,Type,ChildKind)]) -> _lhsIallfields {-# INLINE rule39 #-} rule39 = \ ((_lhsIallnts) :: [Identifier]) -> _lhsIallnts {-# INLINE rule40 #-} rule40 = \ ((_lhsIattrs) :: [(Identifier,Identifier)]) -> _lhsIattrs {-# INLINE rule41 #-} rule41 = \ ((_lhsIcon) :: Identifier) -> _lhsIcon {-# INLINE rule42 #-} rule42 = \ ((_lhsIinh) :: Attributes) -> _lhsIinh {-# INLINE rule43 #-} rule43 = \ ((_lhsIinhMap) :: Map Identifier Attributes) -> _lhsIinhMap {-# INLINE rule44 #-} rule44 = \ ((_lhsImergeMap) :: Map Identifier (Identifier,[Identifier])) -> _lhsImergeMap {-# INLINE rule45 #-} rule45 = \ ((_lhsInt) :: Identifier) -> _lhsInt {-# INLINE rule46 #-} rule46 = \ ((_lhsIo_unbox) :: Bool) -> _lhsIo_unbox {-# INLINE rule47 #-} rule47 = \ ((_lhsIsyn) :: Attributes) -> _lhsIsyn {-# INLINE rule48 #-} rule48 = \ ((_lhsIsynMap) :: Map Identifier Attributes) -> _lhsIsynMap {-# NOINLINE sem_Children_Nil #-} sem_Children_Nil :: T_Children sem_Children_Nil = T_Children (return st5) where {-# NOINLINE st5 #-} st5 = let v4 :: T_Children_v4 v4 = \ (T_Children_vIn4 _lhsIallfields _lhsIallnts _lhsIattrs _lhsIcon _lhsIinh _lhsIinhMap _lhsImergeMap _lhsInt _lhsIo_unbox _lhsIsyn _lhsIsynMap) -> ( let _lhsOfields :: [(Identifier,Type,ChildKind)] _lhsOfields = rule49 () _lhsOattributes :: [(Identifier,Attributes,Attributes)] _lhsOattributes = rule50 () _lhsOcollectChildrenInhs :: Map Identifier Attributes _lhsOcollectChildrenInhs = rule51 () _lhsOcollectChildrenSyns :: Map Identifier Attributes _lhsOcollectChildrenSyns = rule52 () _lhsOerrors :: Seq Error _lhsOerrors = rule53 () _lhsOgathAltAttrs :: [AltAttr] _lhsOgathAltAttrs = rule54 () _lhsOgathRules :: Seq CRule _lhsOgathRules = rule55 () _lhsOinhs :: Seq (Identifier,Attributes) _lhsOinhs = rule56 () _lhsOnts :: Seq (Identifier,NontermIdent) _lhsOnts = rule57 () _lhsOsinglevisits :: [CRule] _lhsOsinglevisits = rule58 () _lhsOterminals :: [Identifier] _lhsOterminals = rule59 () __result_ = T_Children_vOut4 _lhsOattributes _lhsOcollectChildrenInhs _lhsOcollectChildrenSyns _lhsOerrors _lhsOfields _lhsOgathAltAttrs _lhsOgathRules _lhsOinhs _lhsOnts _lhsOsinglevisits _lhsOterminals in __result_ ) in C_Children_s5 v4 {-# INLINE rule49 #-} {-# LINE 676 "./src-ag/Order.ag" #-} rule49 = \ (_ :: ()) -> {-# LINE 676 "./src-ag/Order.ag" #-} [] {-# LINE 629 "dist/build/Order.hs"#-} {-# INLINE rule50 #-} rule50 = \ (_ :: ()) -> [] {-# INLINE rule51 #-} rule51 = \ (_ :: ()) -> Map.empty {-# INLINE rule52 #-} rule52 = \ (_ :: ()) -> Map.empty {-# INLINE rule53 #-} rule53 = \ (_ :: ()) -> Seq.empty {-# INLINE rule54 #-} rule54 = \ (_ :: ()) -> [] {-# INLINE rule55 #-} rule55 = \ (_ :: ()) -> Seq.empty {-# INLINE rule56 #-} rule56 = \ (_ :: ()) -> Seq.empty {-# INLINE rule57 #-} rule57 = \ (_ :: ()) -> Seq.empty {-# INLINE rule58 #-} rule58 = \ (_ :: ()) -> [] {-# INLINE rule59 #-} rule59 = \ (_ :: ()) -> [] -- Expression -------------------------------------------------- -- wrapper data Inh_Expression = Inh_Expression { allfields_Inh_Expression :: ([(Identifier,Type,ChildKind)]), allnts_Inh_Expression :: ([Identifier]), attrs_Inh_Expression :: ([(Identifier,Identifier)]), con_Inh_Expression :: (Identifier), mergeMap_Inh_Expression :: (Map Identifier (Identifier,[Identifier])), nt_Inh_Expression :: (Identifier) } data Syn_Expression = Syn_Expression { allRhsVars_Syn_Expression :: (Set (Identifier,Identifier)), copy_Syn_Expression :: (Expression), errors_Syn_Expression :: (Seq Error), textLines_Syn_Expression :: ([String]), usedAttrs_Syn_Expression :: ([(Identifier,Identifier)]), usedFields_Syn_Expression :: ([Identifier]), usedLocals_Syn_Expression :: ([Identifier]) } {-# INLINABLE wrap_Expression #-} wrap_Expression :: T_Expression -> Inh_Expression -> (Syn_Expression ) wrap_Expression (T_Expression act) (Inh_Expression _lhsIallfields _lhsIallnts _lhsIattrs _lhsIcon _lhsImergeMap _lhsInt) = Control.Monad.Identity.runIdentity ( do sem <- act let arg = T_Expression_vIn7 _lhsIallfields _lhsIallnts _lhsIattrs _lhsIcon _lhsImergeMap _lhsInt (T_Expression_vOut7 _lhsOallRhsVars _lhsOcopy _lhsOerrors _lhsOtextLines _lhsOusedAttrs _lhsOusedFields _lhsOusedLocals) <- return (inv_Expression_s8 sem arg) return (Syn_Expression _lhsOallRhsVars _lhsOcopy _lhsOerrors _lhsOtextLines _lhsOusedAttrs _lhsOusedFields _lhsOusedLocals) ) -- cata {-# INLINE sem_Expression #-} sem_Expression :: Expression -> T_Expression sem_Expression ( Expression pos_ tks_ ) = sem_Expression_Expression pos_ tks_ -- semantic domain newtype T_Expression = T_Expression { attach_T_Expression :: Identity (T_Expression_s8 ) } newtype T_Expression_s8 = C_Expression_s8 { inv_Expression_s8 :: (T_Expression_v7 ) } data T_Expression_s9 = C_Expression_s9 type T_Expression_v7 = (T_Expression_vIn7 ) -> (T_Expression_vOut7 ) data T_Expression_vIn7 = T_Expression_vIn7 ([(Identifier,Type,ChildKind)]) ([Identifier]) ([(Identifier,Identifier)]) (Identifier) (Map Identifier (Identifier,[Identifier])) (Identifier) data T_Expression_vOut7 = T_Expression_vOut7 (Set (Identifier,Identifier)) (Expression) (Seq Error) ([String]) ([(Identifier,Identifier)]) ([Identifier]) ([Identifier]) {-# NOINLINE sem_Expression_Expression #-} sem_Expression_Expression :: (Pos) -> ([HsToken]) -> T_Expression sem_Expression_Expression arg_pos_ arg_tks_ = T_Expression (return st8) where {-# NOINLINE st8 #-} st8 = let v7 :: T_Expression_v7 v7 = \ (T_Expression_vIn7 _lhsIallfields _lhsIallnts _lhsIattrs _lhsIcon _lhsImergeMap _lhsInt) -> ( let (_textLines,_usedAttrs,_usedLocals,_usedFields) = rule60 _lhsIallfields _lhsIallnts _lhsIattrs _lhsIcon _lhsImergeMap _lhsInt arg_tks_ _lhsOerrors :: Seq Error _lhsOerrors = rule61 () _lhsOallRhsVars :: Set (Identifier,Identifier) _lhsOallRhsVars = rule62 _usedAttrs _usedFields _usedLocals _copy = rule63 arg_pos_ arg_tks_ _lhsOcopy :: Expression _lhsOcopy = rule64 _copy _lhsOtextLines :: [String] _lhsOtextLines = rule65 _textLines _lhsOusedAttrs :: [(Identifier,Identifier)] _lhsOusedAttrs = rule66 _usedAttrs _lhsOusedFields :: [Identifier] _lhsOusedFields = rule67 _usedFields _lhsOusedLocals :: [Identifier] _lhsOusedLocals = rule68 _usedLocals __result_ = T_Expression_vOut7 _lhsOallRhsVars _lhsOcopy _lhsOerrors _lhsOtextLines _lhsOusedAttrs _lhsOusedFields _lhsOusedLocals in __result_ ) in C_Expression_s8 v7 {-# INLINE rule60 #-} {-# LINE 466 "./src-ag/Order.ag" #-} rule60 = \ ((_lhsIallfields) :: [(Identifier,Type,ChildKind)]) ((_lhsIallnts) :: [Identifier]) ((_lhsIattrs) :: [(Identifier,Identifier)]) ((_lhsIcon) :: Identifier) ((_lhsImergeMap) :: Map Identifier (Identifier,[Identifier])) ((_lhsInt) :: Identifier) tks_ -> {-# LINE 466 "./src-ag/Order.ag" #-} let mergedChildren = [ x | (_,xs) <- Map.elems _lhsImergeMap, x <- xs ] attrsIn = filter (\(fld,_) -> not (fld `elem` mergedChildren)) _lhsIattrs inherited = Inh_HsTokensRoot { attrs_Inh_HsTokensRoot = attrsIn , con_Inh_HsTokensRoot = _lhsIcon , allfields_Inh_HsTokensRoot = _lhsIallfields , allnts_Inh_HsTokensRoot = _lhsIallnts , nt_Inh_HsTokensRoot = _lhsInt } synthesized = wrap_HsTokensRoot (sem_HsTokensRoot (HsTokensRoot tks_)) inherited in case synthesized of Syn_HsTokensRoot { textLines_Syn_HsTokensRoot = textLines , usedAttrs_Syn_HsTokensRoot = usedAttrs , usedLocals_Syn_HsTokensRoot = usedLocals , usedFields_Syn_HsTokensRoot = usedFields } -> let extraAttrs = [ (src,attr) | (fld,attr) <- usedAttrs, let mbMerged = Map.lookup fld _lhsImergeMap, isJust mbMerged , let (Just (_, srcs)) = mbMerged, src <- srcs ] usedAttrs' = usedAttrs ++ extraAttrs in (textLines,usedAttrs',usedLocals,usedFields) {-# LINE 742 "dist/build/Order.hs"#-} {-# INLINE rule61 #-} {-# LINE 488 "./src-ag/Order.ag" #-} rule61 = \ (_ :: ()) -> {-# LINE 488 "./src-ag/Order.ag" #-} Seq.empty {-# LINE 748 "dist/build/Order.hs"#-} {-# INLINE rule62 #-} {-# LINE 489 "./src-ag/Order.ag" #-} rule62 = \ _usedAttrs _usedFields _usedLocals -> {-# LINE 489 "./src-ag/Order.ag" #-} Set.fromList _usedAttrs `Set.union` Set.fromList [ (_LOC, l) | l <- _usedLocals ] `Set.union` Set.fromList [ (_FIELD, fld) | fld <- _usedFields ] {-# LINE 758 "dist/build/Order.hs"#-} {-# INLINE rule63 #-} rule63 = \ pos_ tks_ -> Expression pos_ tks_ {-# INLINE rule64 #-} rule64 = \ _copy -> _copy {-# INLINE rule65 #-} rule65 = \ _textLines -> _textLines {-# INLINE rule66 #-} rule66 = \ _usedAttrs -> _usedAttrs {-# INLINE rule67 #-} rule67 = \ _usedFields -> _usedFields {-# INLINE rule68 #-} rule68 = \ _usedLocals -> _usedLocals -- Grammar ----------------------------------------------------- -- wrapper data Inh_Grammar = Inh_Grammar { options_Inh_Grammar :: (Options) } data Syn_Grammar = Syn_Grammar { errors_Syn_Grammar :: (Seq Error), nAutoRules_Syn_Grammar :: (Int), nExplicitRules_Syn_Grammar :: (Int), output_Syn_Grammar :: (CGrammar) } {-# INLINABLE wrap_Grammar #-} wrap_Grammar :: T_Grammar -> Inh_Grammar -> (Syn_Grammar ) wrap_Grammar (T_Grammar act) (Inh_Grammar _lhsIoptions) = Control.Monad.Identity.runIdentity ( do sem <- act let arg = T_Grammar_vIn10 _lhsIoptions (T_Grammar_vOut10 _lhsOerrors _lhsOnAutoRules _lhsOnExplicitRules _lhsOoutput) <- return (inv_Grammar_s11 sem arg) return (Syn_Grammar _lhsOerrors _lhsOnAutoRules _lhsOnExplicitRules _lhsOoutput) ) -- cata {-# INLINE sem_Grammar #-} sem_Grammar :: Grammar -> T_Grammar sem_Grammar ( Grammar typeSyns_ useMap_ derivings_ wrappers_ nonts_ pragmas_ manualAttrOrderMap_ paramMap_ contextMap_ quantMap_ uniqueMap_ augmentsMap_ aroundsMap_ mergeMap_ ) = sem_Grammar_Grammar typeSyns_ useMap_ derivings_ wrappers_ ( sem_Nonterminals nonts_ ) pragmas_ manualAttrOrderMap_ paramMap_ contextMap_ quantMap_ uniqueMap_ augmentsMap_ aroundsMap_ mergeMap_ -- semantic domain newtype T_Grammar = T_Grammar { attach_T_Grammar :: Identity (T_Grammar_s11 ) } newtype T_Grammar_s11 = C_Grammar_s11 { inv_Grammar_s11 :: (T_Grammar_v10 ) } data T_Grammar_s12 = C_Grammar_s12 type T_Grammar_v10 = (T_Grammar_vIn10 ) -> (T_Grammar_vOut10 ) data T_Grammar_vIn10 = T_Grammar_vIn10 (Options) data T_Grammar_vOut10 = T_Grammar_vOut10 (Seq Error) (Int) (Int) (CGrammar) {-# NOINLINE sem_Grammar_Grammar #-} sem_Grammar_Grammar :: (TypeSyns) -> (UseMap) -> (Derivings) -> (Set NontermIdent) -> T_Nonterminals -> (PragmaMap) -> (AttrOrderMap) -> (ParamMap) -> (ContextMap) -> (QuantMap) -> (UniqueMap) -> (Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))) -> (Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))) -> (Map NontermIdent (Map ConstructorIdent (Map Identifier (Identifier, [Identifier], Expression)))) -> T_Grammar sem_Grammar_Grammar arg_typeSyns_ _ arg_derivings_ arg_wrappers_ arg_nonts_ arg_pragmas_ arg_manualAttrOrderMap_ arg_paramMap_ arg_contextMap_ arg_quantMap_ _ _ arg_aroundsMap_ arg_mergeMap_ = T_Grammar (return st11) where {-# NOINLINE st11 #-} st11 = let v10 :: T_Grammar_v10 v10 = \ (T_Grammar_vIn10 _lhsIoptions) -> ( let _nontsX17 = Control.Monad.Identity.runIdentity (attach_T_Nonterminals (arg_nonts_)) (T_Nonterminals_vOut16 _nontsIacount _nontsIadditionalDep _nontsIaranges _nontsIaroundDep _nontsIcNonterminals _nontsIdirectDep _nontsIerrors _nontsIinhMap' _nontsIinstDep _nontsImergeDep _nontsInAutoRules _nontsInExplicitRules _nontsInonts _nontsIntattrs _nontsIrules _nontsIsynMap' _nontsIvcount) = inv_Nonterminals_s17 _nontsX17 (T_Nonterminals_vIn16 _nontsOacount _nontsOallnts _nontsOaroundMap _nontsOcInterfaceMap _nontsOcVisitsMap _nontsOinhMap _nontsOmanualAttrDepMap _nontsOmergeMap _nontsOo_case _nontsOo_cata _nontsOo_data _nontsOo_dovisit _nontsOo_newtypes _nontsOo_rename _nontsOo_sem _nontsOo_sig _nontsOo_unbox _nontsOo_wantvisit _nontsOprefix _nontsOsynMap _nontsOvcount) _nontsOinhMap = rule69 _nontsIinhMap' _nontsOsynMap = rule70 _nontsIsynMap' _o_dovisit = rule71 _cyclesErrors _lhsIoptions _nontsOo_cata = rule72 _lhsIoptions _nontsOo_data = rule73 _lhsIoptions _nontsOo_sig = rule74 _lhsIoptions _nontsOo_sem = rule75 _lhsIoptions _nontsOo_rename = rule76 _lhsIoptions _nontsOo_newtypes = rule77 _lhsIoptions _nontsOo_wantvisit = rule78 _lhsIoptions _nontsOo_unbox = rule79 _lhsIoptions _nontsOo_case = rule80 _lhsIoptions _nontsOprefix = rule81 _lhsIoptions _nontsOvcount = rule82 () _nontsOmanualAttrDepMap = rule83 arg_manualAttrOrderMap_ _nontsOaroundMap = rule84 arg_aroundsMap_ _nontsOacount = rule85 () _ruleTable = rule86 _nontsIrules _nontsIvcount _attrTable = rule87 _nontsIacount _nontsIntattrs _attrVertex = rule88 _nontsIntattrs _tdpToTds = rule89 _attrVertex _nontsIrules _tdsToTdp = rule90 _tdpToTds _directDep = rule91 _nontsIadditionalDep _nontsIdirectDep _instDep = rule92 _nontsIinstDep _aroundDep = rule93 _nontsIaroundDep _mergeDep = rule94 _nontsImergeDep _info = rule95 _attrTable _nontsIacount _nontsIaranges _nontsInonts _nontsIvcount _ruleTable _tdpToTds _tdsToTdp arg_wrappers_ (_cInterfaceMap,_cVisitsMap,_cyclesErrors) = rule96 _aroundDep _attrTable _directDep _info _instDep _lhsIoptions _mergeDep _ruleTable _lhsOerrors :: Seq Error _lhsOerrors = rule97 _cyclesErrors _lhsIoptions _nontsIerrors _lhsOoutput :: CGrammar _lhsOoutput = rule98 _aroundMap _mergeMap _nontsIcNonterminals _o_dovisit arg_contextMap_ arg_derivings_ arg_paramMap_ arg_pragmas_ arg_quantMap_ arg_typeSyns_ arg_wrappers_ _aroundMap = rule99 arg_aroundsMap_ _mergeMap = rule100 arg_mergeMap_ _nontsOallnts = rule101 _nontsInonts _lhsOnAutoRules :: Int _lhsOnAutoRules = rule102 _nontsInAutoRules _lhsOnExplicitRules :: Int _lhsOnExplicitRules = rule103 _nontsInExplicitRules _nontsOcInterfaceMap = rule104 _cInterfaceMap _nontsOcVisitsMap = rule105 _cVisitsMap _nontsOmergeMap = rule106 _mergeMap _nontsOo_dovisit = rule107 _o_dovisit __result_ = T_Grammar_vOut10 _lhsOerrors _lhsOnAutoRules _lhsOnExplicitRules _lhsOoutput in __result_ ) in C_Grammar_s11 v10 {-# INLINE rule69 #-} {-# LINE 15 "./src-ag/DistChildAttr.ag" #-} rule69 = \ ((_nontsIinhMap') :: Map Identifier Attributes) -> {-# LINE 15 "./src-ag/DistChildAttr.ag" #-} _nontsIinhMap' {-# LINE 868 "dist/build/Order.hs"#-} {-# INLINE rule70 #-} {-# LINE 16 "./src-ag/DistChildAttr.ag" #-} rule70 = \ ((_nontsIsynMap') :: Map Identifier Attributes) -> {-# LINE 16 "./src-ag/DistChildAttr.ag" #-} _nontsIsynMap' {-# LINE 874 "dist/build/Order.hs"#-} {-# INLINE rule71 #-} {-# LINE 124 "./src-ag/Order.ag" #-} rule71 = \ _cyclesErrors ((_lhsIoptions) :: Options) -> {-# LINE 124 "./src-ag/Order.ag" #-} visit _lhsIoptions && null _cyclesErrors {-# LINE 880 "dist/build/Order.hs"#-} {-# INLINE rule72 #-} {-# LINE 125 "./src-ag/Order.ag" #-} rule72 = \ ((_lhsIoptions) :: Options) -> {-# LINE 125 "./src-ag/Order.ag" #-} folds _lhsIoptions {-# LINE 886 "dist/build/Order.hs"#-} {-# INLINE rule73 #-} {-# LINE 126 "./src-ag/Order.ag" #-} rule73 = \ ((_lhsIoptions) :: Options) -> {-# LINE 126 "./src-ag/Order.ag" #-} dataTypes _lhsIoptions {-# LINE 892 "dist/build/Order.hs"#-} {-# INLINE rule74 #-} {-# LINE 127 "./src-ag/Order.ag" #-} rule74 = \ ((_lhsIoptions) :: Options) -> {-# LINE 127 "./src-ag/Order.ag" #-} typeSigs _lhsIoptions {-# LINE 898 "dist/build/Order.hs"#-} {-# INLINE rule75 #-} {-# LINE 128 "./src-ag/Order.ag" #-} rule75 = \ ((_lhsIoptions) :: Options) -> {-# LINE 128 "./src-ag/Order.ag" #-} semfuns _lhsIoptions {-# LINE 904 "dist/build/Order.hs"#-} {-# INLINE rule76 #-} {-# LINE 129 "./src-ag/Order.ag" #-} rule76 = \ ((_lhsIoptions) :: Options) -> {-# LINE 129 "./src-ag/Order.ag" #-} rename _lhsIoptions {-# LINE 910 "dist/build/Order.hs"#-} {-# INLINE rule77 #-} {-# LINE 130 "./src-ag/Order.ag" #-} rule77 = \ ((_lhsIoptions) :: Options) -> {-# LINE 130 "./src-ag/Order.ag" #-} newtypes _lhsIoptions {-# LINE 916 "dist/build/Order.hs"#-} {-# INLINE rule78 #-} {-# LINE 131 "./src-ag/Order.ag" #-} rule78 = \ ((_lhsIoptions) :: Options) -> {-# LINE 131 "./src-ag/Order.ag" #-} visit _lhsIoptions {-# LINE 922 "dist/build/Order.hs"#-} {-# INLINE rule79 #-} {-# LINE 132 "./src-ag/Order.ag" #-} rule79 = \ ((_lhsIoptions) :: Options) -> {-# LINE 132 "./src-ag/Order.ag" #-} unbox _lhsIoptions {-# LINE 928 "dist/build/Order.hs"#-} {-# INLINE rule80 #-} {-# LINE 133 "./src-ag/Order.ag" #-} rule80 = \ ((_lhsIoptions) :: Options) -> {-# LINE 133 "./src-ag/Order.ag" #-} cases _lhsIoptions {-# LINE 934 "dist/build/Order.hs"#-} {-# INLINE rule81 #-} {-# LINE 134 "./src-ag/Order.ag" #-} rule81 = \ ((_lhsIoptions) :: Options) -> {-# LINE 134 "./src-ag/Order.ag" #-} prefix _lhsIoptions {-# LINE 940 "dist/build/Order.hs"#-} {-# INLINE rule82 #-} {-# LINE 260 "./src-ag/Order.ag" #-} rule82 = \ (_ :: ()) -> {-# LINE 260 "./src-ag/Order.ag" #-} 0 {-# LINE 946 "dist/build/Order.hs"#-} {-# INLINE rule83 #-} {-# LINE 286 "./src-ag/Order.ag" #-} rule83 = \ manualAttrOrderMap_ -> {-# LINE 286 "./src-ag/Order.ag" #-} manualAttrOrderMap_ {-# LINE 952 "dist/build/Order.hs"#-} {-# INLINE rule84 #-} {-# LINE 415 "./src-ag/Order.ag" #-} rule84 = \ aroundsMap_ -> {-# LINE 415 "./src-ag/Order.ag" #-} aroundsMap_ {-# LINE 958 "dist/build/Order.hs"#-} {-# INLINE rule85 #-} {-# LINE 504 "./src-ag/Order.ag" #-} rule85 = \ (_ :: ()) -> {-# LINE 504 "./src-ag/Order.ag" #-} 0 {-# LINE 964 "dist/build/Order.hs"#-} {-# INLINE rule86 #-} {-# LINE 542 "./src-ag/Order.ag" #-} rule86 = \ ((_nontsIrules) :: Seq (Vertex,CRule)) ((_nontsIvcount) :: Int) -> {-# LINE 542 "./src-ag/Order.ag" #-} Array.array (0,_nontsIvcount-1) (toList _nontsIrules) {-# LINE 970 "dist/build/Order.hs"#-} {-# INLINE rule87 #-} {-# LINE 543 "./src-ag/Order.ag" #-} rule87 = \ ((_nontsIacount) :: Int) ((_nontsIntattrs) :: Seq (Vertex,NTAttr)) -> {-# LINE 543 "./src-ag/Order.ag" #-} Array.array (0,_nontsIacount-1) (toList _nontsIntattrs) {-# LINE 976 "dist/build/Order.hs"#-} {-# INLINE rule88 #-} {-# LINE 544 "./src-ag/Order.ag" #-} rule88 = \ ((_nontsIntattrs) :: Seq (Vertex,NTAttr)) -> {-# LINE 544 "./src-ag/Order.ag" #-} Map.fromList (map swap (toList _nontsIntattrs)) {-# LINE 982 "dist/build/Order.hs"#-} {-# INLINE rule89 #-} {-# LINE 545 "./src-ag/Order.ag" #-} rule89 = \ _attrVertex ((_nontsIrules) :: Seq (Vertex,CRule)) -> {-# LINE 545 "./src-ag/Order.ag" #-} [ (s, maybe (-1) (\v -> findWithErr1 "Grammar.tdpToTds" v _attrVertex) (ntattr cr)) | (s,cr) <- toList _nontsIrules] {-# LINE 989 "dist/build/Order.hs"#-} {-# INLINE rule90 #-} {-# LINE 547 "./src-ag/Order.ag" #-} rule90 = \ _tdpToTds -> {-# LINE 547 "./src-ag/Order.ag" #-} let eq (_,v) (_,v') = v == v' conv ((s,v):svs) | v == -1 = Nothing | otherwise = Just (v,s:map fst svs) in mapMaybe conv (eqClasses eq _tdpToTds) {-# LINE 998 "dist/build/Order.hs"#-} {-# INLINE rule91 #-} {-# LINE 551 "./src-ag/Order.ag" #-} rule91 = \ ((_nontsIadditionalDep) :: Seq Edge) ((_nontsIdirectDep) :: Seq Edge) -> {-# LINE 551 "./src-ag/Order.ag" #-} toList (_nontsIdirectDep Seq.>< _nontsIadditionalDep) {-# LINE 1004 "dist/build/Order.hs"#-} {-# INLINE rule92 #-} {-# LINE 552 "./src-ag/Order.ag" #-} rule92 = \ ((_nontsIinstDep) :: Seq Edge) -> {-# LINE 552 "./src-ag/Order.ag" #-} toList _nontsIinstDep {-# LINE 1010 "dist/build/Order.hs"#-} {-# INLINE rule93 #-} {-# LINE 553 "./src-ag/Order.ag" #-} rule93 = \ ((_nontsIaroundDep) :: Seq Edge) -> {-# LINE 553 "./src-ag/Order.ag" #-} toList _nontsIaroundDep {-# LINE 1016 "dist/build/Order.hs"#-} {-# INLINE rule94 #-} {-# LINE 554 "./src-ag/Order.ag" #-} rule94 = \ ((_nontsImergeDep) :: Seq Edge) -> {-# LINE 554 "./src-ag/Order.ag" #-} toList _nontsImergeDep {-# LINE 1022 "dist/build/Order.hs"#-} {-# INLINE rule95 #-} {-# LINE 555 "./src-ag/Order.ag" #-} rule95 = \ _attrTable ((_nontsIacount) :: Int) ((_nontsIaranges) :: Seq (Int,Int,Int)) ((_nontsInonts) :: [(NontermIdent,[ConstructorIdent])]) ((_nontsIvcount) :: Int) _ruleTable _tdpToTds _tdsToTdp wrappers_ -> {-# LINE 555 "./src-ag/Order.ag" #-} let def [] = -1 def (v:vs) = v in Info { tdsToTdp = Array.array (0,_nontsIacount-1) _tdsToTdp , tdpToTds = Array.array (0,_nontsIvcount-1) _tdpToTds , attrTable = _attrTable , ruleTable = _ruleTable , lmh = toList _nontsIaranges , nonts = _nontsInonts , wraps = wrappers_ } {-# LINE 1037 "dist/build/Order.hs"#-} {-# INLINE rule96 #-} {-# LINE 567 "./src-ag/Order.ag" #-} rule96 = \ _aroundDep _attrTable _directDep _info _instDep ((_lhsIoptions) :: Options) _mergeDep _ruleTable -> {-# LINE 567 "./src-ag/Order.ag" #-} case computeSequential _info _directDep (_instDep ++ _aroundDep ++ _mergeDep ) of CycleFree cim cvm -> ( cim , cvm , [] ) LocalCycle errs -> ( error "No interfaces for AG with local cycles" , error "No visit sub-sequences for AG with local cycles" , map (localCycleErr _ruleTable (visit _lhsIoptions)) errs ) InstCycle errs -> ( error "No interfaces for AG with cycles through insts" , error "No visit sub-sequences for AG with cycles through insts" , map (instCycleErr _ruleTable (visit _lhsIoptions)) errs ) DirectCycle errs -> ( error "No interfaces for AG with direct cycles" , error "No visit sub-sequences for AG with direct cycles" , directCycleErrs _attrTable _ruleTable (visit _lhsIoptions) errs ) InducedCycle cim errs -> ( cim , error "No visit sub-sequences for AG with induced cycles" , inducedCycleErrs _attrTable _ruleTable cim errs ) {-# LINE 1063 "dist/build/Order.hs"#-} {-# INLINE rule97 #-} {-# LINE 588 "./src-ag/Order.ag" #-} rule97 = \ _cyclesErrors ((_lhsIoptions) :: Options) ((_nontsIerrors) :: Seq Error) -> {-# LINE 588 "./src-ag/Order.ag" #-} (if withCycle _lhsIoptions then Seq.fromList _cyclesErrors else Seq.empty) Seq.>< _nontsIerrors {-# LINE 1070 "dist/build/Order.hs"#-} {-# INLINE rule98 #-} {-# LINE 620 "./src-ag/Order.ag" #-} rule98 = \ _aroundMap _mergeMap ((_nontsIcNonterminals) :: CNonterminals) _o_dovisit contextMap_ derivings_ paramMap_ pragmas_ quantMap_ typeSyns_ wrappers_ -> {-# LINE 620 "./src-ag/Order.ag" #-} CGrammar typeSyns_ derivings_ wrappers_ _nontsIcNonterminals pragmas_ paramMap_ contextMap_ quantMap_ _aroundMap _mergeMap _o_dovisit {-# LINE 1076 "dist/build/Order.hs"#-} {-# INLINE rule99 #-} {-# LINE 633 "./src-ag/Order.ag" #-} rule99 = \ aroundsMap_ -> {-# LINE 633 "./src-ag/Order.ag" #-} Map.map (Map.map Map.keysSet) aroundsMap_ {-# LINE 1082 "dist/build/Order.hs"#-} {-# INLINE rule100 #-} {-# LINE 634 "./src-ag/Order.ag" #-} rule100 = \ mergeMap_ -> {-# LINE 634 "./src-ag/Order.ag" #-} Map.map (Map.map (Map.map (\(nt,srcs,_) -> (nt,srcs)))) mergeMap_ {-# LINE 1088 "dist/build/Order.hs"#-} {-# INLINE rule101 #-} {-# LINE 651 "./src-ag/Order.ag" #-} rule101 = \ ((_nontsInonts) :: [(NontermIdent,[ConstructorIdent])]) -> {-# LINE 651 "./src-ag/Order.ag" #-} map fst (_nontsInonts) {-# LINE 1094 "dist/build/Order.hs"#-} {-# INLINE rule102 #-} rule102 = \ ((_nontsInAutoRules) :: Int) -> _nontsInAutoRules {-# INLINE rule103 #-} rule103 = \ ((_nontsInExplicitRules) :: Int) -> _nontsInExplicitRules {-# INLINE rule104 #-} rule104 = \ _cInterfaceMap -> _cInterfaceMap {-# INLINE rule105 #-} rule105 = \ _cVisitsMap -> _cVisitsMap {-# INLINE rule106 #-} rule106 = \ _mergeMap -> _mergeMap {-# INLINE rule107 #-} rule107 = \ _o_dovisit -> _o_dovisit -- Nonterminal ------------------------------------------------- -- wrapper data Inh_Nonterminal = Inh_Nonterminal { acount_Inh_Nonterminal :: (Int), allnts_Inh_Nonterminal :: ([Identifier]), aroundMap_Inh_Nonterminal :: (Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))), cInterfaceMap_Inh_Nonterminal :: (CInterfaceMap), cVisitsMap_Inh_Nonterminal :: (CVisitsMap), inhMap_Inh_Nonterminal :: (Map Identifier Attributes), manualAttrDepMap_Inh_Nonterminal :: (AttrOrderMap), mergeMap_Inh_Nonterminal :: (Map NontermIdent (Map ConstructorIdent (Map Identifier (Identifier,[Identifier])))), o_case_Inh_Nonterminal :: (Bool), o_cata_Inh_Nonterminal :: (Bool), o_data_Inh_Nonterminal :: (Bool), o_dovisit_Inh_Nonterminal :: (Bool), o_newtypes_Inh_Nonterminal :: (Bool), o_rename_Inh_Nonterminal :: (Bool), o_sem_Inh_Nonterminal :: (Bool), o_sig_Inh_Nonterminal :: (Bool), o_unbox_Inh_Nonterminal :: (Bool), o_wantvisit_Inh_Nonterminal :: (Bool), prefix_Inh_Nonterminal :: (String), synMap_Inh_Nonterminal :: (Map Identifier Attributes), vcount_Inh_Nonterminal :: (Int) } data Syn_Nonterminal = Syn_Nonterminal { acount_Syn_Nonterminal :: (Int), additionalDep_Syn_Nonterminal :: (Seq Edge), aranges_Syn_Nonterminal :: (Seq (Int,Int,Int)), aroundDep_Syn_Nonterminal :: (Seq Edge), cNonterminal_Syn_Nonterminal :: (CNonterminal), directDep_Syn_Nonterminal :: (Seq Edge), errors_Syn_Nonterminal :: (Seq Error), inhMap'_Syn_Nonterminal :: (Map Identifier Attributes), instDep_Syn_Nonterminal :: (Seq Edge), mergeDep_Syn_Nonterminal :: (Seq Edge), nAutoRules_Syn_Nonterminal :: (Int), nExplicitRules_Syn_Nonterminal :: (Int), nonts_Syn_Nonterminal :: ([(NontermIdent,[ConstructorIdent])]), ntattrs_Syn_Nonterminal :: (Seq (Vertex,NTAttr)), rules_Syn_Nonterminal :: (Seq (Vertex,CRule)), synMap'_Syn_Nonterminal :: (Map Identifier Attributes), vcount_Syn_Nonterminal :: (Int) } {-# INLINABLE wrap_Nonterminal #-} wrap_Nonterminal :: T_Nonterminal -> Inh_Nonterminal -> (Syn_Nonterminal ) wrap_Nonterminal (T_Nonterminal act) (Inh_Nonterminal _lhsIacount _lhsIallnts _lhsIaroundMap _lhsIcInterfaceMap _lhsIcVisitsMap _lhsIinhMap _lhsImanualAttrDepMap _lhsImergeMap _lhsIo_case _lhsIo_cata _lhsIo_data _lhsIo_dovisit _lhsIo_newtypes _lhsIo_rename _lhsIo_sem _lhsIo_sig _lhsIo_unbox _lhsIo_wantvisit _lhsIprefix _lhsIsynMap _lhsIvcount) = Control.Monad.Identity.runIdentity ( do sem <- act let arg = T_Nonterminal_vIn13 _lhsIacount _lhsIallnts _lhsIaroundMap _lhsIcInterfaceMap _lhsIcVisitsMap _lhsIinhMap _lhsImanualAttrDepMap _lhsImergeMap _lhsIo_case _lhsIo_cata _lhsIo_data _lhsIo_dovisit _lhsIo_newtypes _lhsIo_rename _lhsIo_sem _lhsIo_sig _lhsIo_unbox _lhsIo_wantvisit _lhsIprefix _lhsIsynMap _lhsIvcount (T_Nonterminal_vOut13 _lhsOacount _lhsOadditionalDep _lhsOaranges _lhsOaroundDep _lhsOcNonterminal _lhsOdirectDep _lhsOerrors _lhsOinhMap' _lhsOinstDep _lhsOmergeDep _lhsOnAutoRules _lhsOnExplicitRules _lhsOnonts _lhsOntattrs _lhsOrules _lhsOsynMap' _lhsOvcount) <- return (inv_Nonterminal_s14 sem arg) return (Syn_Nonterminal _lhsOacount _lhsOadditionalDep _lhsOaranges _lhsOaroundDep _lhsOcNonterminal _lhsOdirectDep _lhsOerrors _lhsOinhMap' _lhsOinstDep _lhsOmergeDep _lhsOnAutoRules _lhsOnExplicitRules _lhsOnonts _lhsOntattrs _lhsOrules _lhsOsynMap' _lhsOvcount) ) -- cata {-# INLINE sem_Nonterminal #-} sem_Nonterminal :: Nonterminal -> T_Nonterminal sem_Nonterminal ( Nonterminal nt_ params_ inh_ syn_ prods_ ) = sem_Nonterminal_Nonterminal nt_ params_ inh_ syn_ ( sem_Productions prods_ ) -- semantic domain newtype T_Nonterminal = T_Nonterminal { attach_T_Nonterminal :: Identity (T_Nonterminal_s14 ) } newtype T_Nonterminal_s14 = C_Nonterminal_s14 { inv_Nonterminal_s14 :: (T_Nonterminal_v13 ) } data T_Nonterminal_s15 = C_Nonterminal_s15 type T_Nonterminal_v13 = (T_Nonterminal_vIn13 ) -> (T_Nonterminal_vOut13 ) data T_Nonterminal_vIn13 = T_Nonterminal_vIn13 (Int) ([Identifier]) (Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))) (CInterfaceMap) (CVisitsMap) (Map Identifier Attributes) (AttrOrderMap) (Map NontermIdent (Map ConstructorIdent (Map Identifier (Identifier,[Identifier])))) (Bool) (Bool) (Bool) (Bool) (Bool) (Bool) (Bool) (Bool) (Bool) (Bool) (String) (Map Identifier Attributes) (Int) data T_Nonterminal_vOut13 = T_Nonterminal_vOut13 (Int) (Seq Edge) (Seq (Int,Int,Int)) (Seq Edge) (CNonterminal) (Seq Edge) (Seq Error) (Map Identifier Attributes) (Seq Edge) (Seq Edge) (Int) (Int) ([(NontermIdent,[ConstructorIdent])]) (Seq (Vertex,NTAttr)) (Seq (Vertex,CRule)) (Map Identifier Attributes) (Int) {-# NOINLINE sem_Nonterminal_Nonterminal #-} sem_Nonterminal_Nonterminal :: (NontermIdent) -> ([Identifier]) -> (Attributes) -> (Attributes) -> T_Productions -> T_Nonterminal sem_Nonterminal_Nonterminal arg_nt_ arg_params_ arg_inh_ arg_syn_ arg_prods_ = T_Nonterminal (return st14) where {-# NOINLINE st14 #-} st14 = let v13 :: T_Nonterminal_v13 v13 = \ (T_Nonterminal_vIn13 _lhsIacount _lhsIallnts _lhsIaroundMap _lhsIcInterfaceMap _lhsIcVisitsMap _lhsIinhMap _lhsImanualAttrDepMap _lhsImergeMap _lhsIo_case _lhsIo_cata _lhsIo_data _lhsIo_dovisit _lhsIo_newtypes _lhsIo_rename _lhsIo_sem _lhsIo_sig _lhsIo_unbox _lhsIo_wantvisit _lhsIprefix _lhsIsynMap _lhsIvcount) -> ( let _prodsX29 = Control.Monad.Identity.runIdentity (attach_T_Productions (arg_prods_)) (T_Productions_vOut28 _prodsIadditionalDep _prodsIaroundDep _prodsIcProductions _prodsIcons _prodsIdirectDep _prodsIerrors _prodsIinstDep _prodsImergeDep _prodsInAutoRules _prodsInExplicitRules _prodsIrules _prodsIvcount) = inv_Productions_s29 _prodsX29 (T_Productions_vIn28 _prodsOallnts _prodsOaroundMap _prodsOcVisitsMap _prodsOinh _prodsOinhMap _prodsOmanualAttrDepMap _prodsOmergeMap _prodsOnt _prodsOo_case _prodsOo_cata _prodsOo_dovisit _prodsOo_newtypes _prodsOo_rename _prodsOo_sem _prodsOo_sig _prodsOo_unbox _prodsOo_wantvisit _prodsOprefix _prodsOsyn _prodsOsynMap _prodsOvcount) _lhsOinhMap' :: Map Identifier Attributes _lhsOinhMap' = rule108 arg_inh_ arg_nt_ _lhsOsynMap' :: Map Identifier Attributes _lhsOsynMap' = rule109 arg_nt_ arg_syn_ _prodsOnt = rule110 arg_nt_ _prodsOinh = rule111 arg_inh_ _prodsOsyn = rule112 arg_syn_ _mergeMap = rule113 _lhsImergeMap arg_nt_ _aroundMap = rule114 _lhsIaroundMap arg_nt_ _ntattrs = rule115 arg_inh_ arg_nt_ arg_syn_ _lhsOntattrs :: Seq (Vertex,NTAttr) _lhsOntattrs = rule116 _lhsIacount _ntattrs _lhsOacount :: Int _lhsOacount = rule117 _lhsIacount arg_inh_ arg_syn_ _lhsOaranges :: Seq (Int,Int,Int) _lhsOaranges = rule118 _lhsIacount arg_inh_ arg_syn_ _lhsOnonts :: [(NontermIdent,[ConstructorIdent])] _lhsOnonts = rule119 _prodsIcons arg_nt_ _cInter = rule120 _lhsIcInterfaceMap _lhsIo_dovisit arg_inh_ arg_nt_ arg_syn_ _lhsOcNonterminal :: CNonterminal _lhsOcNonterminal = rule121 _cInter _prodsIcProductions arg_inh_ arg_nt_ arg_params_ arg_syn_ _lhsOadditionalDep :: Seq Edge _lhsOadditionalDep = rule122 _prodsIadditionalDep _lhsOaroundDep :: Seq Edge _lhsOaroundDep = rule123 _prodsIaroundDep _lhsOdirectDep :: Seq Edge _lhsOdirectDep = rule124 _prodsIdirectDep _lhsOerrors :: Seq Error _lhsOerrors = rule125 _prodsIerrors _lhsOinstDep :: Seq Edge _lhsOinstDep = rule126 _prodsIinstDep _lhsOmergeDep :: Seq Edge _lhsOmergeDep = rule127 _prodsImergeDep _lhsOnAutoRules :: Int _lhsOnAutoRules = rule128 _prodsInAutoRules _lhsOnExplicitRules :: Int _lhsOnExplicitRules = rule129 _prodsInExplicitRules _lhsOrules :: Seq (Vertex,CRule) _lhsOrules = rule130 _prodsIrules _lhsOvcount :: Int _lhsOvcount = rule131 _prodsIvcount _prodsOallnts = rule132 _lhsIallnts _prodsOaroundMap = rule133 _aroundMap _prodsOcVisitsMap = rule134 _lhsIcVisitsMap _prodsOinhMap = rule135 _lhsIinhMap _prodsOmanualAttrDepMap = rule136 _lhsImanualAttrDepMap _prodsOmergeMap = rule137 _mergeMap _prodsOo_case = rule138 _lhsIo_case _prodsOo_cata = rule139 _lhsIo_cata _prodsOo_dovisit = rule140 _lhsIo_dovisit _prodsOo_newtypes = rule141 _lhsIo_newtypes _prodsOo_rename = rule142 _lhsIo_rename _prodsOo_sem = rule143 _lhsIo_sem _prodsOo_sig = rule144 _lhsIo_sig _prodsOo_unbox = rule145 _lhsIo_unbox _prodsOo_wantvisit = rule146 _lhsIo_wantvisit _prodsOprefix = rule147 _lhsIprefix _prodsOsynMap = rule148 _lhsIsynMap _prodsOvcount = rule149 _lhsIvcount __result_ = T_Nonterminal_vOut13 _lhsOacount _lhsOadditionalDep _lhsOaranges _lhsOaroundDep _lhsOcNonterminal _lhsOdirectDep _lhsOerrors _lhsOinhMap' _lhsOinstDep _lhsOmergeDep _lhsOnAutoRules _lhsOnExplicitRules _lhsOnonts _lhsOntattrs _lhsOrules _lhsOsynMap' _lhsOvcount in __result_ ) in C_Nonterminal_s14 v13 {-# INLINE rule108 #-} {-# LINE 7 "./src-ag/DistChildAttr.ag" #-} rule108 = \ inh_ nt_ -> {-# LINE 7 "./src-ag/DistChildAttr.ag" #-} Map.singleton nt_ inh_ {-# LINE 1220 "dist/build/Order.hs"#-} {-# INLINE rule109 #-} {-# LINE 8 "./src-ag/DistChildAttr.ag" #-} rule109 = \ nt_ syn_ -> {-# LINE 8 "./src-ag/DistChildAttr.ag" #-} Map.singleton nt_ syn_ {-# LINE 1226 "dist/build/Order.hs"#-} {-# INLINE rule110 #-} {-# LINE 98 "./src-ag/Order.ag" #-} rule110 = \ nt_ -> {-# LINE 98 "./src-ag/Order.ag" #-} nt_ {-# LINE 1232 "dist/build/Order.hs"#-} {-# INLINE rule111 #-} {-# LINE 101 "./src-ag/Order.ag" #-} rule111 = \ inh_ -> {-# LINE 101 "./src-ag/Order.ag" #-} inh_ {-# LINE 1238 "dist/build/Order.hs"#-} {-# INLINE rule112 #-} {-# LINE 102 "./src-ag/Order.ag" #-} rule112 = \ syn_ -> {-# LINE 102 "./src-ag/Order.ag" #-} syn_ {-# LINE 1244 "dist/build/Order.hs"#-} {-# INLINE rule113 #-} {-# LINE 358 "./src-ag/Order.ag" #-} rule113 = \ ((_lhsImergeMap) :: Map NontermIdent (Map ConstructorIdent (Map Identifier (Identifier,[Identifier])))) nt_ -> {-# LINE 358 "./src-ag/Order.ag" #-} Map.findWithDefault Map.empty nt_ _lhsImergeMap {-# LINE 1250 "dist/build/Order.hs"#-} {-# INLINE rule114 #-} {-# LINE 411 "./src-ag/Order.ag" #-} rule114 = \ ((_lhsIaroundMap) :: Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))) nt_ -> {-# LINE 411 "./src-ag/Order.ag" #-} Map.findWithDefault Map.empty nt_ _lhsIaroundMap {-# LINE 1256 "dist/build/Order.hs"#-} {-# INLINE rule115 #-} {-# LINE 507 "./src-ag/Order.ag" #-} rule115 = \ inh_ nt_ syn_ -> {-# LINE 507 "./src-ag/Order.ag" #-} [ NTAInh nt_ inh tp | (inh,tp) <- Map.assocs inh_ ] ++ [NTASyn nt_ syn tp | (syn,tp) <- Map.assocs syn_ ] {-# LINE 1263 "dist/build/Order.hs"#-} {-# INLINE rule116 #-} {-# LINE 509 "./src-ag/Order.ag" #-} rule116 = \ ((_lhsIacount) :: Int) _ntattrs -> {-# LINE 509 "./src-ag/Order.ag" #-} Seq.fromList (zip [_lhsIacount ..] _ntattrs) {-# LINE 1269 "dist/build/Order.hs"#-} {-# INLINE rule117 #-} {-# LINE 510 "./src-ag/Order.ag" #-} rule117 = \ ((_lhsIacount) :: Int) inh_ syn_ -> {-# LINE 510 "./src-ag/Order.ag" #-} _lhsIacount + Map.size inh_ + Map.size syn_ {-# LINE 1275 "dist/build/Order.hs"#-} {-# INLINE rule118 #-} {-# LINE 511 "./src-ag/Order.ag" #-} rule118 = \ ((_lhsIacount) :: Int) inh_ syn_ -> {-# LINE 511 "./src-ag/Order.ag" #-} Seq.singleton (_lhsIacount ,_lhsIacount + Map.size inh_ ,_lhsIacount + Map.size syn_ + Map.size inh_ - 1) {-# LINE 1284 "dist/build/Order.hs"#-} {-# INLINE rule119 #-} {-# LINE 520 "./src-ag/Order.ag" #-} rule119 = \ ((_prodsIcons) :: [ConstructorIdent]) nt_ -> {-# LINE 520 "./src-ag/Order.ag" #-} [(nt_,_prodsIcons)] {-# LINE 1290 "dist/build/Order.hs"#-} {-# INLINE rule120 #-} {-# LINE 597 "./src-ag/Order.ag" #-} rule120 = \ ((_lhsIcInterfaceMap) :: CInterfaceMap) ((_lhsIo_dovisit) :: Bool) inh_ nt_ syn_ -> {-# LINE 597 "./src-ag/Order.ag" #-} if _lhsIo_dovisit then findWithErr1 "Nonterminal.cInter" nt_ _lhsIcInterfaceMap else CInterface [CSegment inh_ syn_] {-# LINE 1298 "dist/build/Order.hs"#-} {-# INLINE rule121 #-} {-# LINE 625 "./src-ag/Order.ag" #-} rule121 = \ _cInter ((_prodsIcProductions) :: CProductions) inh_ nt_ params_ syn_ -> {-# LINE 625 "./src-ag/Order.ag" #-} CNonterminal nt_ params_ inh_ syn_ _prodsIcProductions _cInter {-# LINE 1304 "dist/build/Order.hs"#-} {-# INLINE rule122 #-} rule122 = \ ((_prodsIadditionalDep) :: Seq Edge) -> _prodsIadditionalDep {-# INLINE rule123 #-} rule123 = \ ((_prodsIaroundDep) :: Seq Edge) -> _prodsIaroundDep {-# INLINE rule124 #-} rule124 = \ ((_prodsIdirectDep) :: Seq Edge) -> _prodsIdirectDep {-# INLINE rule125 #-} rule125 = \ ((_prodsIerrors) :: Seq Error) -> _prodsIerrors {-# INLINE rule126 #-} rule126 = \ ((_prodsIinstDep) :: Seq Edge) -> _prodsIinstDep {-# INLINE rule127 #-} rule127 = \ ((_prodsImergeDep) :: Seq Edge) -> _prodsImergeDep {-# INLINE rule128 #-} rule128 = \ ((_prodsInAutoRules) :: Int) -> _prodsInAutoRules {-# INLINE rule129 #-} rule129 = \ ((_prodsInExplicitRules) :: Int) -> _prodsInExplicitRules {-# INLINE rule130 #-} rule130 = \ ((_prodsIrules) :: Seq (Vertex,CRule)) -> _prodsIrules {-# INLINE rule131 #-} rule131 = \ ((_prodsIvcount) :: Int) -> _prodsIvcount {-# INLINE rule132 #-} rule132 = \ ((_lhsIallnts) :: [Identifier]) -> _lhsIallnts {-# INLINE rule133 #-} rule133 = \ _aroundMap -> _aroundMap {-# INLINE rule134 #-} rule134 = \ ((_lhsIcVisitsMap) :: CVisitsMap) -> _lhsIcVisitsMap {-# INLINE rule135 #-} rule135 = \ ((_lhsIinhMap) :: Map Identifier Attributes) -> _lhsIinhMap {-# INLINE rule136 #-} rule136 = \ ((_lhsImanualAttrDepMap) :: AttrOrderMap) -> _lhsImanualAttrDepMap {-# INLINE rule137 #-} rule137 = \ _mergeMap -> _mergeMap {-# INLINE rule138 #-} rule138 = \ ((_lhsIo_case) :: Bool) -> _lhsIo_case {-# INLINE rule139 #-} rule139 = \ ((_lhsIo_cata) :: Bool) -> _lhsIo_cata {-# INLINE rule140 #-} rule140 = \ ((_lhsIo_dovisit) :: Bool) -> _lhsIo_dovisit {-# INLINE rule141 #-} rule141 = \ ((_lhsIo_newtypes) :: Bool) -> _lhsIo_newtypes {-# INLINE rule142 #-} rule142 = \ ((_lhsIo_rename) :: Bool) -> _lhsIo_rename {-# INLINE rule143 #-} rule143 = \ ((_lhsIo_sem) :: Bool) -> _lhsIo_sem {-# INLINE rule144 #-} rule144 = \ ((_lhsIo_sig) :: Bool) -> _lhsIo_sig {-# INLINE rule145 #-} rule145 = \ ((_lhsIo_unbox) :: Bool) -> _lhsIo_unbox {-# INLINE rule146 #-} rule146 = \ ((_lhsIo_wantvisit) :: Bool) -> _lhsIo_wantvisit {-# INLINE rule147 #-} rule147 = \ ((_lhsIprefix) :: String) -> _lhsIprefix {-# INLINE rule148 #-} rule148 = \ ((_lhsIsynMap) :: Map Identifier Attributes) -> _lhsIsynMap {-# INLINE rule149 #-} rule149 = \ ((_lhsIvcount) :: Int) -> _lhsIvcount -- Nonterminals ------------------------------------------------ -- wrapper data Inh_Nonterminals = Inh_Nonterminals { acount_Inh_Nonterminals :: (Int), allnts_Inh_Nonterminals :: ([Identifier]), aroundMap_Inh_Nonterminals :: (Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))), cInterfaceMap_Inh_Nonterminals :: (CInterfaceMap), cVisitsMap_Inh_Nonterminals :: (CVisitsMap), inhMap_Inh_Nonterminals :: (Map Identifier Attributes), manualAttrDepMap_Inh_Nonterminals :: (AttrOrderMap), mergeMap_Inh_Nonterminals :: (Map NontermIdent (Map ConstructorIdent (Map Identifier (Identifier,[Identifier])))), o_case_Inh_Nonterminals :: (Bool), o_cata_Inh_Nonterminals :: (Bool), o_data_Inh_Nonterminals :: (Bool), o_dovisit_Inh_Nonterminals :: (Bool), o_newtypes_Inh_Nonterminals :: (Bool), o_rename_Inh_Nonterminals :: (Bool), o_sem_Inh_Nonterminals :: (Bool), o_sig_Inh_Nonterminals :: (Bool), o_unbox_Inh_Nonterminals :: (Bool), o_wantvisit_Inh_Nonterminals :: (Bool), prefix_Inh_Nonterminals :: (String), synMap_Inh_Nonterminals :: (Map Identifier Attributes), vcount_Inh_Nonterminals :: (Int) } data Syn_Nonterminals = Syn_Nonterminals { acount_Syn_Nonterminals :: (Int), additionalDep_Syn_Nonterminals :: (Seq Edge), aranges_Syn_Nonterminals :: (Seq (Int,Int,Int)), aroundDep_Syn_Nonterminals :: (Seq Edge), cNonterminals_Syn_Nonterminals :: (CNonterminals), directDep_Syn_Nonterminals :: (Seq Edge), errors_Syn_Nonterminals :: (Seq Error), inhMap'_Syn_Nonterminals :: (Map Identifier Attributes), instDep_Syn_Nonterminals :: (Seq Edge), mergeDep_Syn_Nonterminals :: (Seq Edge), nAutoRules_Syn_Nonterminals :: (Int), nExplicitRules_Syn_Nonterminals :: (Int), nonts_Syn_Nonterminals :: ([(NontermIdent,[ConstructorIdent])]), ntattrs_Syn_Nonterminals :: (Seq (Vertex,NTAttr)), rules_Syn_Nonterminals :: (Seq (Vertex,CRule)), synMap'_Syn_Nonterminals :: (Map Identifier Attributes), vcount_Syn_Nonterminals :: (Int) } {-# INLINABLE wrap_Nonterminals #-} wrap_Nonterminals :: T_Nonterminals -> Inh_Nonterminals -> (Syn_Nonterminals ) wrap_Nonterminals (T_Nonterminals act) (Inh_Nonterminals _lhsIacount _lhsIallnts _lhsIaroundMap _lhsIcInterfaceMap _lhsIcVisitsMap _lhsIinhMap _lhsImanualAttrDepMap _lhsImergeMap _lhsIo_case _lhsIo_cata _lhsIo_data _lhsIo_dovisit _lhsIo_newtypes _lhsIo_rename _lhsIo_sem _lhsIo_sig _lhsIo_unbox _lhsIo_wantvisit _lhsIprefix _lhsIsynMap _lhsIvcount) = Control.Monad.Identity.runIdentity ( do sem <- act let arg = T_Nonterminals_vIn16 _lhsIacount _lhsIallnts _lhsIaroundMap _lhsIcInterfaceMap _lhsIcVisitsMap _lhsIinhMap _lhsImanualAttrDepMap _lhsImergeMap _lhsIo_case _lhsIo_cata _lhsIo_data _lhsIo_dovisit _lhsIo_newtypes _lhsIo_rename _lhsIo_sem _lhsIo_sig _lhsIo_unbox _lhsIo_wantvisit _lhsIprefix _lhsIsynMap _lhsIvcount (T_Nonterminals_vOut16 _lhsOacount _lhsOadditionalDep _lhsOaranges _lhsOaroundDep _lhsOcNonterminals _lhsOdirectDep _lhsOerrors _lhsOinhMap' _lhsOinstDep _lhsOmergeDep _lhsOnAutoRules _lhsOnExplicitRules _lhsOnonts _lhsOntattrs _lhsOrules _lhsOsynMap' _lhsOvcount) <- return (inv_Nonterminals_s17 sem arg) return (Syn_Nonterminals _lhsOacount _lhsOadditionalDep _lhsOaranges _lhsOaroundDep _lhsOcNonterminals _lhsOdirectDep _lhsOerrors _lhsOinhMap' _lhsOinstDep _lhsOmergeDep _lhsOnAutoRules _lhsOnExplicitRules _lhsOnonts _lhsOntattrs _lhsOrules _lhsOsynMap' _lhsOvcount) ) -- cata {-# NOINLINE sem_Nonterminals #-} sem_Nonterminals :: Nonterminals -> T_Nonterminals sem_Nonterminals list = Prelude.foldr sem_Nonterminals_Cons sem_Nonterminals_Nil (Prelude.map sem_Nonterminal list) -- semantic domain newtype T_Nonterminals = T_Nonterminals { attach_T_Nonterminals :: Identity (T_Nonterminals_s17 ) } newtype T_Nonterminals_s17 = C_Nonterminals_s17 { inv_Nonterminals_s17 :: (T_Nonterminals_v16 ) } data T_Nonterminals_s18 = C_Nonterminals_s18 type T_Nonterminals_v16 = (T_Nonterminals_vIn16 ) -> (T_Nonterminals_vOut16 ) data T_Nonterminals_vIn16 = T_Nonterminals_vIn16 (Int) ([Identifier]) (Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))) (CInterfaceMap) (CVisitsMap) (Map Identifier Attributes) (AttrOrderMap) (Map NontermIdent (Map ConstructorIdent (Map Identifier (Identifier,[Identifier])))) (Bool) (Bool) (Bool) (Bool) (Bool) (Bool) (Bool) (Bool) (Bool) (Bool) (String) (Map Identifier Attributes) (Int) data T_Nonterminals_vOut16 = T_Nonterminals_vOut16 (Int) (Seq Edge) (Seq (Int,Int,Int)) (Seq Edge) (CNonterminals) (Seq Edge) (Seq Error) (Map Identifier Attributes) (Seq Edge) (Seq Edge) (Int) (Int) ([(NontermIdent,[ConstructorIdent])]) (Seq (Vertex,NTAttr)) (Seq (Vertex,CRule)) (Map Identifier Attributes) (Int) {-# NOINLINE sem_Nonterminals_Cons #-} sem_Nonterminals_Cons :: T_Nonterminal -> T_Nonterminals -> T_Nonterminals sem_Nonterminals_Cons arg_hd_ arg_tl_ = T_Nonterminals (return st17) where {-# NOINLINE st17 #-} st17 = let v16 :: T_Nonterminals_v16 v16 = \ (T_Nonterminals_vIn16 _lhsIacount _lhsIallnts _lhsIaroundMap _lhsIcInterfaceMap _lhsIcVisitsMap _lhsIinhMap _lhsImanualAttrDepMap _lhsImergeMap _lhsIo_case _lhsIo_cata _lhsIo_data _lhsIo_dovisit _lhsIo_newtypes _lhsIo_rename _lhsIo_sem _lhsIo_sig _lhsIo_unbox _lhsIo_wantvisit _lhsIprefix _lhsIsynMap _lhsIvcount) -> ( let _hdX14 = Control.Monad.Identity.runIdentity (attach_T_Nonterminal (arg_hd_)) _tlX17 = Control.Monad.Identity.runIdentity (attach_T_Nonterminals (arg_tl_)) (T_Nonterminal_vOut13 _hdIacount _hdIadditionalDep _hdIaranges _hdIaroundDep _hdIcNonterminal _hdIdirectDep _hdIerrors _hdIinhMap' _hdIinstDep _hdImergeDep _hdInAutoRules _hdInExplicitRules _hdInonts _hdIntattrs _hdIrules _hdIsynMap' _hdIvcount) = inv_Nonterminal_s14 _hdX14 (T_Nonterminal_vIn13 _hdOacount _hdOallnts _hdOaroundMap _hdOcInterfaceMap _hdOcVisitsMap _hdOinhMap _hdOmanualAttrDepMap _hdOmergeMap _hdOo_case _hdOo_cata _hdOo_data _hdOo_dovisit _hdOo_newtypes _hdOo_rename _hdOo_sem _hdOo_sig _hdOo_unbox _hdOo_wantvisit _hdOprefix _hdOsynMap _hdOvcount) (T_Nonterminals_vOut16 _tlIacount _tlIadditionalDep _tlIaranges _tlIaroundDep _tlIcNonterminals _tlIdirectDep _tlIerrors _tlIinhMap' _tlIinstDep _tlImergeDep _tlInAutoRules _tlInExplicitRules _tlInonts _tlIntattrs _tlIrules _tlIsynMap' _tlIvcount) = inv_Nonterminals_s17 _tlX17 (T_Nonterminals_vIn16 _tlOacount _tlOallnts _tlOaroundMap _tlOcInterfaceMap _tlOcVisitsMap _tlOinhMap _tlOmanualAttrDepMap _tlOmergeMap _tlOo_case _tlOo_cata _tlOo_data _tlOo_dovisit _tlOo_newtypes _tlOo_rename _tlOo_sem _tlOo_sig _tlOo_unbox _tlOo_wantvisit _tlOprefix _tlOsynMap _tlOvcount) _lhsOcNonterminals :: CNonterminals _lhsOcNonterminals = rule150 _hdIcNonterminal _tlIcNonterminals _lhsOadditionalDep :: Seq Edge _lhsOadditionalDep = rule151 _hdIadditionalDep _tlIadditionalDep _lhsOaranges :: Seq (Int,Int,Int) _lhsOaranges = rule152 _hdIaranges _tlIaranges _lhsOaroundDep :: Seq Edge _lhsOaroundDep = rule153 _hdIaroundDep _tlIaroundDep _lhsOdirectDep :: Seq Edge _lhsOdirectDep = rule154 _hdIdirectDep _tlIdirectDep _lhsOerrors :: Seq Error _lhsOerrors = rule155 _hdIerrors _tlIerrors _lhsOinhMap' :: Map Identifier Attributes _lhsOinhMap' = rule156 _hdIinhMap' _tlIinhMap' _lhsOinstDep :: Seq Edge _lhsOinstDep = rule157 _hdIinstDep _tlIinstDep _lhsOmergeDep :: Seq Edge _lhsOmergeDep = rule158 _hdImergeDep _tlImergeDep _lhsOnAutoRules :: Int _lhsOnAutoRules = rule159 _hdInAutoRules _tlInAutoRules _lhsOnExplicitRules :: Int _lhsOnExplicitRules = rule160 _hdInExplicitRules _tlInExplicitRules _lhsOnonts :: [(NontermIdent,[ConstructorIdent])] _lhsOnonts = rule161 _hdInonts _tlInonts _lhsOntattrs :: Seq (Vertex,NTAttr) _lhsOntattrs = rule162 _hdIntattrs _tlIntattrs _lhsOrules :: Seq (Vertex,CRule) _lhsOrules = rule163 _hdIrules _tlIrules _lhsOsynMap' :: Map Identifier Attributes _lhsOsynMap' = rule164 _hdIsynMap' _tlIsynMap' _lhsOacount :: Int _lhsOacount = rule165 _tlIacount _lhsOvcount :: Int _lhsOvcount = rule166 _tlIvcount _hdOacount = rule167 _lhsIacount _hdOallnts = rule168 _lhsIallnts _hdOaroundMap = rule169 _lhsIaroundMap _hdOcInterfaceMap = rule170 _lhsIcInterfaceMap _hdOcVisitsMap = rule171 _lhsIcVisitsMap _hdOinhMap = rule172 _lhsIinhMap _hdOmanualAttrDepMap = rule173 _lhsImanualAttrDepMap _hdOmergeMap = rule174 _lhsImergeMap _hdOo_case = rule175 _lhsIo_case _hdOo_cata = rule176 _lhsIo_cata _hdOo_data = rule177 _lhsIo_data _hdOo_dovisit = rule178 _lhsIo_dovisit _hdOo_newtypes = rule179 _lhsIo_newtypes _hdOo_rename = rule180 _lhsIo_rename _hdOo_sem = rule181 _lhsIo_sem _hdOo_sig = rule182 _lhsIo_sig _hdOo_unbox = rule183 _lhsIo_unbox _hdOo_wantvisit = rule184 _lhsIo_wantvisit _hdOprefix = rule185 _lhsIprefix _hdOsynMap = rule186 _lhsIsynMap _hdOvcount = rule187 _lhsIvcount _tlOacount = rule188 _hdIacount _tlOallnts = rule189 _lhsIallnts _tlOaroundMap = rule190 _lhsIaroundMap _tlOcInterfaceMap = rule191 _lhsIcInterfaceMap _tlOcVisitsMap = rule192 _lhsIcVisitsMap _tlOinhMap = rule193 _lhsIinhMap _tlOmanualAttrDepMap = rule194 _lhsImanualAttrDepMap _tlOmergeMap = rule195 _lhsImergeMap _tlOo_case = rule196 _lhsIo_case _tlOo_cata = rule197 _lhsIo_cata _tlOo_data = rule198 _lhsIo_data _tlOo_dovisit = rule199 _lhsIo_dovisit _tlOo_newtypes = rule200 _lhsIo_newtypes _tlOo_rename = rule201 _lhsIo_rename _tlOo_sem = rule202 _lhsIo_sem _tlOo_sig = rule203 _lhsIo_sig _tlOo_unbox = rule204 _lhsIo_unbox _tlOo_wantvisit = rule205 _lhsIo_wantvisit _tlOprefix = rule206 _lhsIprefix _tlOsynMap = rule207 _lhsIsynMap _tlOvcount = rule208 _hdIvcount __result_ = T_Nonterminals_vOut16 _lhsOacount _lhsOadditionalDep _lhsOaranges _lhsOaroundDep _lhsOcNonterminals _lhsOdirectDep _lhsOerrors _lhsOinhMap' _lhsOinstDep _lhsOmergeDep _lhsOnAutoRules _lhsOnExplicitRules _lhsOnonts _lhsOntattrs _lhsOrules _lhsOsynMap' _lhsOvcount in __result_ ) in C_Nonterminals_s17 v16 {-# INLINE rule150 #-} {-# LINE 622 "./src-ag/Order.ag" #-} rule150 = \ ((_hdIcNonterminal) :: CNonterminal) ((_tlIcNonterminals) :: CNonterminals) -> {-# LINE 622 "./src-ag/Order.ag" #-} _hdIcNonterminal : _tlIcNonterminals {-# LINE 1515 "dist/build/Order.hs"#-} {-# INLINE rule151 #-} rule151 = \ ((_hdIadditionalDep) :: Seq Edge) ((_tlIadditionalDep) :: Seq Edge) -> _hdIadditionalDep Seq.>< _tlIadditionalDep {-# INLINE rule152 #-} rule152 = \ ((_hdIaranges) :: Seq (Int,Int,Int)) ((_tlIaranges) :: Seq (Int,Int,Int)) -> _hdIaranges Seq.>< _tlIaranges {-# INLINE rule153 #-} rule153 = \ ((_hdIaroundDep) :: Seq Edge) ((_tlIaroundDep) :: Seq Edge) -> _hdIaroundDep Seq.>< _tlIaroundDep {-# INLINE rule154 #-} rule154 = \ ((_hdIdirectDep) :: Seq Edge) ((_tlIdirectDep) :: Seq Edge) -> _hdIdirectDep Seq.>< _tlIdirectDep {-# INLINE rule155 #-} rule155 = \ ((_hdIerrors) :: Seq Error) ((_tlIerrors) :: Seq Error) -> _hdIerrors Seq.>< _tlIerrors {-# INLINE rule156 #-} rule156 = \ ((_hdIinhMap') :: Map Identifier Attributes) ((_tlIinhMap') :: Map Identifier Attributes) -> _hdIinhMap' `Map.union` _tlIinhMap' {-# INLINE rule157 #-} rule157 = \ ((_hdIinstDep) :: Seq Edge) ((_tlIinstDep) :: Seq Edge) -> _hdIinstDep Seq.>< _tlIinstDep {-# INLINE rule158 #-} rule158 = \ ((_hdImergeDep) :: Seq Edge) ((_tlImergeDep) :: Seq Edge) -> _hdImergeDep Seq.>< _tlImergeDep {-# INLINE rule159 #-} rule159 = \ ((_hdInAutoRules) :: Int) ((_tlInAutoRules) :: Int) -> _hdInAutoRules + _tlInAutoRules {-# INLINE rule160 #-} rule160 = \ ((_hdInExplicitRules) :: Int) ((_tlInExplicitRules) :: Int) -> _hdInExplicitRules + _tlInExplicitRules {-# INLINE rule161 #-} rule161 = \ ((_hdInonts) :: [(NontermIdent,[ConstructorIdent])]) ((_tlInonts) :: [(NontermIdent,[ConstructorIdent])]) -> _hdInonts ++ _tlInonts {-# INLINE rule162 #-} rule162 = \ ((_hdIntattrs) :: Seq (Vertex,NTAttr)) ((_tlIntattrs) :: Seq (Vertex,NTAttr)) -> _hdIntattrs Seq.>< _tlIntattrs {-# INLINE rule163 #-} rule163 = \ ((_hdIrules) :: Seq (Vertex,CRule)) ((_tlIrules) :: Seq (Vertex,CRule)) -> _hdIrules Seq.>< _tlIrules {-# INLINE rule164 #-} rule164 = \ ((_hdIsynMap') :: Map Identifier Attributes) ((_tlIsynMap') :: Map Identifier Attributes) -> _hdIsynMap' `Map.union` _tlIsynMap' {-# INLINE rule165 #-} rule165 = \ ((_tlIacount) :: Int) -> _tlIacount {-# INLINE rule166 #-} rule166 = \ ((_tlIvcount) :: Int) -> _tlIvcount {-# INLINE rule167 #-} rule167 = \ ((_lhsIacount) :: Int) -> _lhsIacount {-# INLINE rule168 #-} rule168 = \ ((_lhsIallnts) :: [Identifier]) -> _lhsIallnts {-# INLINE rule169 #-} rule169 = \ ((_lhsIaroundMap) :: Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))) -> _lhsIaroundMap {-# INLINE rule170 #-} rule170 = \ ((_lhsIcInterfaceMap) :: CInterfaceMap) -> _lhsIcInterfaceMap {-# INLINE rule171 #-} rule171 = \ ((_lhsIcVisitsMap) :: CVisitsMap) -> _lhsIcVisitsMap {-# INLINE rule172 #-} rule172 = \ ((_lhsIinhMap) :: Map Identifier Attributes) -> _lhsIinhMap {-# INLINE rule173 #-} rule173 = \ ((_lhsImanualAttrDepMap) :: AttrOrderMap) -> _lhsImanualAttrDepMap {-# INLINE rule174 #-} rule174 = \ ((_lhsImergeMap) :: Map NontermIdent (Map ConstructorIdent (Map Identifier (Identifier,[Identifier])))) -> _lhsImergeMap {-# INLINE rule175 #-} rule175 = \ ((_lhsIo_case) :: Bool) -> _lhsIo_case {-# INLINE rule176 #-} rule176 = \ ((_lhsIo_cata) :: Bool) -> _lhsIo_cata {-# INLINE rule177 #-} rule177 = \ ((_lhsIo_data) :: Bool) -> _lhsIo_data {-# INLINE rule178 #-} rule178 = \ ((_lhsIo_dovisit) :: Bool) -> _lhsIo_dovisit {-# INLINE rule179 #-} rule179 = \ ((_lhsIo_newtypes) :: Bool) -> _lhsIo_newtypes {-# INLINE rule180 #-} rule180 = \ ((_lhsIo_rename) :: Bool) -> _lhsIo_rename {-# INLINE rule181 #-} rule181 = \ ((_lhsIo_sem) :: Bool) -> _lhsIo_sem {-# INLINE rule182 #-} rule182 = \ ((_lhsIo_sig) :: Bool) -> _lhsIo_sig {-# INLINE rule183 #-} rule183 = \ ((_lhsIo_unbox) :: Bool) -> _lhsIo_unbox {-# INLINE rule184 #-} rule184 = \ ((_lhsIo_wantvisit) :: Bool) -> _lhsIo_wantvisit {-# INLINE rule185 #-} rule185 = \ ((_lhsIprefix) :: String) -> _lhsIprefix {-# INLINE rule186 #-} rule186 = \ ((_lhsIsynMap) :: Map Identifier Attributes) -> _lhsIsynMap {-# INLINE rule187 #-} rule187 = \ ((_lhsIvcount) :: Int) -> _lhsIvcount {-# INLINE rule188 #-} rule188 = \ ((_hdIacount) :: Int) -> _hdIacount {-# INLINE rule189 #-} rule189 = \ ((_lhsIallnts) :: [Identifier]) -> _lhsIallnts {-# INLINE rule190 #-} rule190 = \ ((_lhsIaroundMap) :: Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))) -> _lhsIaroundMap {-# INLINE rule191 #-} rule191 = \ ((_lhsIcInterfaceMap) :: CInterfaceMap) -> _lhsIcInterfaceMap {-# INLINE rule192 #-} rule192 = \ ((_lhsIcVisitsMap) :: CVisitsMap) -> _lhsIcVisitsMap {-# INLINE rule193 #-} rule193 = \ ((_lhsIinhMap) :: Map Identifier Attributes) -> _lhsIinhMap {-# INLINE rule194 #-} rule194 = \ ((_lhsImanualAttrDepMap) :: AttrOrderMap) -> _lhsImanualAttrDepMap {-# INLINE rule195 #-} rule195 = \ ((_lhsImergeMap) :: Map NontermIdent (Map ConstructorIdent (Map Identifier (Identifier,[Identifier])))) -> _lhsImergeMap {-# INLINE rule196 #-} rule196 = \ ((_lhsIo_case) :: Bool) -> _lhsIo_case {-# INLINE rule197 #-} rule197 = \ ((_lhsIo_cata) :: Bool) -> _lhsIo_cata {-# INLINE rule198 #-} rule198 = \ ((_lhsIo_data) :: Bool) -> _lhsIo_data {-# INLINE rule199 #-} rule199 = \ ((_lhsIo_dovisit) :: Bool) -> _lhsIo_dovisit {-# INLINE rule200 #-} rule200 = \ ((_lhsIo_newtypes) :: Bool) -> _lhsIo_newtypes {-# INLINE rule201 #-} rule201 = \ ((_lhsIo_rename) :: Bool) -> _lhsIo_rename {-# INLINE rule202 #-} rule202 = \ ((_lhsIo_sem) :: Bool) -> _lhsIo_sem {-# INLINE rule203 #-} rule203 = \ ((_lhsIo_sig) :: Bool) -> _lhsIo_sig {-# INLINE rule204 #-} rule204 = \ ((_lhsIo_unbox) :: Bool) -> _lhsIo_unbox {-# INLINE rule205 #-} rule205 = \ ((_lhsIo_wantvisit) :: Bool) -> _lhsIo_wantvisit {-# INLINE rule206 #-} rule206 = \ ((_lhsIprefix) :: String) -> _lhsIprefix {-# INLINE rule207 #-} rule207 = \ ((_lhsIsynMap) :: Map Identifier Attributes) -> _lhsIsynMap {-# INLINE rule208 #-} rule208 = \ ((_hdIvcount) :: Int) -> _hdIvcount {-# NOINLINE sem_Nonterminals_Nil #-} sem_Nonterminals_Nil :: T_Nonterminals sem_Nonterminals_Nil = T_Nonterminals (return st17) where {-# NOINLINE st17 #-} st17 = let v16 :: T_Nonterminals_v16 v16 = \ (T_Nonterminals_vIn16 _lhsIacount _lhsIallnts _lhsIaroundMap _lhsIcInterfaceMap _lhsIcVisitsMap _lhsIinhMap _lhsImanualAttrDepMap _lhsImergeMap _lhsIo_case _lhsIo_cata _lhsIo_data _lhsIo_dovisit _lhsIo_newtypes _lhsIo_rename _lhsIo_sem _lhsIo_sig _lhsIo_unbox _lhsIo_wantvisit _lhsIprefix _lhsIsynMap _lhsIvcount) -> ( let _lhsOcNonterminals :: CNonterminals _lhsOcNonterminals = rule209 () _lhsOadditionalDep :: Seq Edge _lhsOadditionalDep = rule210 () _lhsOaranges :: Seq (Int,Int,Int) _lhsOaranges = rule211 () _lhsOaroundDep :: Seq Edge _lhsOaroundDep = rule212 () _lhsOdirectDep :: Seq Edge _lhsOdirectDep = rule213 () _lhsOerrors :: Seq Error _lhsOerrors = rule214 () _lhsOinhMap' :: Map Identifier Attributes _lhsOinhMap' = rule215 () _lhsOinstDep :: Seq Edge _lhsOinstDep = rule216 () _lhsOmergeDep :: Seq Edge _lhsOmergeDep = rule217 () _lhsOnAutoRules :: Int _lhsOnAutoRules = rule218 () _lhsOnExplicitRules :: Int _lhsOnExplicitRules = rule219 () _lhsOnonts :: [(NontermIdent,[ConstructorIdent])] _lhsOnonts = rule220 () _lhsOntattrs :: Seq (Vertex,NTAttr) _lhsOntattrs = rule221 () _lhsOrules :: Seq (Vertex,CRule) _lhsOrules = rule222 () _lhsOsynMap' :: Map Identifier Attributes _lhsOsynMap' = rule223 () _lhsOacount :: Int _lhsOacount = rule224 _lhsIacount _lhsOvcount :: Int _lhsOvcount = rule225 _lhsIvcount __result_ = T_Nonterminals_vOut16 _lhsOacount _lhsOadditionalDep _lhsOaranges _lhsOaroundDep _lhsOcNonterminals _lhsOdirectDep _lhsOerrors _lhsOinhMap' _lhsOinstDep _lhsOmergeDep _lhsOnAutoRules _lhsOnExplicitRules _lhsOnonts _lhsOntattrs _lhsOrules _lhsOsynMap' _lhsOvcount in __result_ ) in C_Nonterminals_s17 v16 {-# INLINE rule209 #-} {-# LINE 623 "./src-ag/Order.ag" #-} rule209 = \ (_ :: ()) -> {-# LINE 623 "./src-ag/Order.ag" #-} [] {-# LINE 1739 "dist/build/Order.hs"#-} {-# INLINE rule210 #-} rule210 = \ (_ :: ()) -> Seq.empty {-# INLINE rule211 #-} rule211 = \ (_ :: ()) -> Seq.empty {-# INLINE rule212 #-} rule212 = \ (_ :: ()) -> Seq.empty {-# INLINE rule213 #-} rule213 = \ (_ :: ()) -> Seq.empty {-# INLINE rule214 #-} rule214 = \ (_ :: ()) -> Seq.empty {-# INLINE rule215 #-} rule215 = \ (_ :: ()) -> Map.empty {-# INLINE rule216 #-} rule216 = \ (_ :: ()) -> Seq.empty {-# INLINE rule217 #-} rule217 = \ (_ :: ()) -> Seq.empty {-# INLINE rule218 #-} rule218 = \ (_ :: ()) -> 0 {-# INLINE rule219 #-} rule219 = \ (_ :: ()) -> 0 {-# INLINE rule220 #-} rule220 = \ (_ :: ()) -> [] {-# INLINE rule221 #-} rule221 = \ (_ :: ()) -> Seq.empty {-# INLINE rule222 #-} rule222 = \ (_ :: ()) -> Seq.empty {-# INLINE rule223 #-} rule223 = \ (_ :: ()) -> Map.empty {-# INLINE rule224 #-} rule224 = \ ((_lhsIacount) :: Int) -> _lhsIacount {-# INLINE rule225 #-} rule225 = \ ((_lhsIvcount) :: Int) -> _lhsIvcount -- Pattern ----------------------------------------------------- -- wrapper data Inh_Pattern = Inh_Pattern { allTypeSigs_Inh_Pattern :: (Map Identifier Type), altAttrs_Inh_Pattern :: (Map AltAttr Vertex), con_Inh_Pattern :: (Identifier), inh_Inh_Pattern :: (Attributes), nt_Inh_Pattern :: (Identifier), syn_Inh_Pattern :: (Attributes) } data Syn_Pattern = Syn_Pattern { copy_Syn_Pattern :: (Pattern), errors_Syn_Pattern :: (Seq Error), gathAltAttrs_Syn_Pattern :: ([AltAttr]), instVars_Syn_Pattern :: ([Identifier]), locVars_Syn_Pattern :: ([Identifier]), patternAttrs_Syn_Pattern :: ([(Identifier,Identifier,Bool)]) } {-# INLINABLE wrap_Pattern #-} wrap_Pattern :: T_Pattern -> Inh_Pattern -> (Syn_Pattern ) wrap_Pattern (T_Pattern act) (Inh_Pattern _lhsIallTypeSigs _lhsIaltAttrs _lhsIcon _lhsIinh _lhsInt _lhsIsyn) = Control.Monad.Identity.runIdentity ( do sem <- act let arg = T_Pattern_vIn19 _lhsIallTypeSigs _lhsIaltAttrs _lhsIcon _lhsIinh _lhsInt _lhsIsyn (T_Pattern_vOut19 _lhsOcopy _lhsOerrors _lhsOgathAltAttrs _lhsOinstVars _lhsOlocVars _lhsOpatternAttrs) <- return (inv_Pattern_s20 sem arg) return (Syn_Pattern _lhsOcopy _lhsOerrors _lhsOgathAltAttrs _lhsOinstVars _lhsOlocVars _lhsOpatternAttrs) ) -- cata {-# NOINLINE sem_Pattern #-} sem_Pattern :: Pattern -> T_Pattern sem_Pattern ( Constr name_ pats_ ) = sem_Pattern_Constr name_ ( sem_Patterns pats_ ) sem_Pattern ( Product pos_ pats_ ) = sem_Pattern_Product pos_ ( sem_Patterns pats_ ) sem_Pattern ( Alias field_ attr_ pat_ ) = sem_Pattern_Alias field_ attr_ ( sem_Pattern pat_ ) sem_Pattern ( Irrefutable pat_ ) = sem_Pattern_Irrefutable ( sem_Pattern pat_ ) sem_Pattern ( Underscore pos_ ) = sem_Pattern_Underscore pos_ -- semantic domain newtype T_Pattern = T_Pattern { attach_T_Pattern :: Identity (T_Pattern_s20 ) } newtype T_Pattern_s20 = C_Pattern_s20 { inv_Pattern_s20 :: (T_Pattern_v19 ) } data T_Pattern_s21 = C_Pattern_s21 type T_Pattern_v19 = (T_Pattern_vIn19 ) -> (T_Pattern_vOut19 ) data T_Pattern_vIn19 = T_Pattern_vIn19 (Map Identifier Type) (Map AltAttr Vertex) (Identifier) (Attributes) (Identifier) (Attributes) data T_Pattern_vOut19 = T_Pattern_vOut19 (Pattern) (Seq Error) ([AltAttr]) ([Identifier]) ([Identifier]) ([(Identifier,Identifier,Bool)]) {-# NOINLINE sem_Pattern_Constr #-} sem_Pattern_Constr :: (ConstructorIdent) -> T_Patterns -> T_Pattern sem_Pattern_Constr arg_name_ arg_pats_ = T_Pattern (return st20) where {-# NOINLINE st20 #-} st20 = let v19 :: T_Pattern_v19 v19 = \ (T_Pattern_vIn19 _lhsIallTypeSigs _lhsIaltAttrs _lhsIcon _lhsIinh _lhsInt _lhsIsyn) -> ( let _patsX23 = Control.Monad.Identity.runIdentity (attach_T_Patterns (arg_pats_)) (T_Patterns_vOut22 _patsIcopy _patsIerrors _patsIgathAltAttrs _patsIinstVars _patsIlocVars _patsIpatternAttrs) = inv_Patterns_s23 _patsX23 (T_Patterns_vIn22 _patsOallTypeSigs _patsOaltAttrs _patsOcon _patsOinh _patsOnt _patsOsyn) _lhsOerrors :: Seq Error _lhsOerrors = rule226 _patsIerrors _lhsOgathAltAttrs :: [AltAttr] _lhsOgathAltAttrs = rule227 _patsIgathAltAttrs _lhsOinstVars :: [Identifier] _lhsOinstVars = rule228 _patsIinstVars _lhsOlocVars :: [Identifier] _lhsOlocVars = rule229 _patsIlocVars _lhsOpatternAttrs :: [(Identifier,Identifier,Bool)] _lhsOpatternAttrs = rule230 _patsIpatternAttrs _copy = rule231 _patsIcopy arg_name_ _lhsOcopy :: Pattern _lhsOcopy = rule232 _copy _patsOallTypeSigs = rule233 _lhsIallTypeSigs _patsOaltAttrs = rule234 _lhsIaltAttrs _patsOcon = rule235 _lhsIcon _patsOinh = rule236 _lhsIinh _patsOnt = rule237 _lhsInt _patsOsyn = rule238 _lhsIsyn __result_ = T_Pattern_vOut19 _lhsOcopy _lhsOerrors _lhsOgathAltAttrs _lhsOinstVars _lhsOlocVars _lhsOpatternAttrs in __result_ ) in C_Pattern_s20 v19 {-# INLINE rule226 #-} rule226 = \ ((_patsIerrors) :: Seq Error) -> _patsIerrors {-# INLINE rule227 #-} rule227 = \ ((_patsIgathAltAttrs) :: [AltAttr]) -> _patsIgathAltAttrs {-# INLINE rule228 #-} rule228 = \ ((_patsIinstVars) :: [Identifier]) -> _patsIinstVars {-# INLINE rule229 #-} rule229 = \ ((_patsIlocVars) :: [Identifier]) -> _patsIlocVars {-# INLINE rule230 #-} rule230 = \ ((_patsIpatternAttrs) :: [(Identifier,Identifier,Bool)]) -> _patsIpatternAttrs {-# INLINE rule231 #-} rule231 = \ ((_patsIcopy) :: Patterns) name_ -> Constr name_ _patsIcopy {-# INLINE rule232 #-} rule232 = \ _copy -> _copy {-# INLINE rule233 #-} rule233 = \ ((_lhsIallTypeSigs) :: Map Identifier Type) -> _lhsIallTypeSigs {-# INLINE rule234 #-} rule234 = \ ((_lhsIaltAttrs) :: Map AltAttr Vertex) -> _lhsIaltAttrs {-# INLINE rule235 #-} rule235 = \ ((_lhsIcon) :: Identifier) -> _lhsIcon {-# INLINE rule236 #-} rule236 = \ ((_lhsIinh) :: Attributes) -> _lhsIinh {-# INLINE rule237 #-} rule237 = \ ((_lhsInt) :: Identifier) -> _lhsInt {-# INLINE rule238 #-} rule238 = \ ((_lhsIsyn) :: Attributes) -> _lhsIsyn {-# NOINLINE sem_Pattern_Product #-} sem_Pattern_Product :: (Pos) -> T_Patterns -> T_Pattern sem_Pattern_Product arg_pos_ arg_pats_ = T_Pattern (return st20) where {-# NOINLINE st20 #-} st20 = let v19 :: T_Pattern_v19 v19 = \ (T_Pattern_vIn19 _lhsIallTypeSigs _lhsIaltAttrs _lhsIcon _lhsIinh _lhsInt _lhsIsyn) -> ( let _patsX23 = Control.Monad.Identity.runIdentity (attach_T_Patterns (arg_pats_)) (T_Patterns_vOut22 _patsIcopy _patsIerrors _patsIgathAltAttrs _patsIinstVars _patsIlocVars _patsIpatternAttrs) = inv_Patterns_s23 _patsX23 (T_Patterns_vIn22 _patsOallTypeSigs _patsOaltAttrs _patsOcon _patsOinh _patsOnt _patsOsyn) _lhsOerrors :: Seq Error _lhsOerrors = rule239 _patsIerrors _lhsOgathAltAttrs :: [AltAttr] _lhsOgathAltAttrs = rule240 _patsIgathAltAttrs _lhsOinstVars :: [Identifier] _lhsOinstVars = rule241 _patsIinstVars _lhsOlocVars :: [Identifier] _lhsOlocVars = rule242 _patsIlocVars _lhsOpatternAttrs :: [(Identifier,Identifier,Bool)] _lhsOpatternAttrs = rule243 _patsIpatternAttrs _copy = rule244 _patsIcopy arg_pos_ _lhsOcopy :: Pattern _lhsOcopy = rule245 _copy _patsOallTypeSigs = rule246 _lhsIallTypeSigs _patsOaltAttrs = rule247 _lhsIaltAttrs _patsOcon = rule248 _lhsIcon _patsOinh = rule249 _lhsIinh _patsOnt = rule250 _lhsInt _patsOsyn = rule251 _lhsIsyn __result_ = T_Pattern_vOut19 _lhsOcopy _lhsOerrors _lhsOgathAltAttrs _lhsOinstVars _lhsOlocVars _lhsOpatternAttrs in __result_ ) in C_Pattern_s20 v19 {-# INLINE rule239 #-} rule239 = \ ((_patsIerrors) :: Seq Error) -> _patsIerrors {-# INLINE rule240 #-} rule240 = \ ((_patsIgathAltAttrs) :: [AltAttr]) -> _patsIgathAltAttrs {-# INLINE rule241 #-} rule241 = \ ((_patsIinstVars) :: [Identifier]) -> _patsIinstVars {-# INLINE rule242 #-} rule242 = \ ((_patsIlocVars) :: [Identifier]) -> _patsIlocVars {-# INLINE rule243 #-} rule243 = \ ((_patsIpatternAttrs) :: [(Identifier,Identifier,Bool)]) -> _patsIpatternAttrs {-# INLINE rule244 #-} rule244 = \ ((_patsIcopy) :: Patterns) pos_ -> Product pos_ _patsIcopy {-# INLINE rule245 #-} rule245 = \ _copy -> _copy {-# INLINE rule246 #-} rule246 = \ ((_lhsIallTypeSigs) :: Map Identifier Type) -> _lhsIallTypeSigs {-# INLINE rule247 #-} rule247 = \ ((_lhsIaltAttrs) :: Map AltAttr Vertex) -> _lhsIaltAttrs {-# INLINE rule248 #-} rule248 = \ ((_lhsIcon) :: Identifier) -> _lhsIcon {-# INLINE rule249 #-} rule249 = \ ((_lhsIinh) :: Attributes) -> _lhsIinh {-# INLINE rule250 #-} rule250 = \ ((_lhsInt) :: Identifier) -> _lhsInt {-# INLINE rule251 #-} rule251 = \ ((_lhsIsyn) :: Attributes) -> _lhsIsyn {-# NOINLINE sem_Pattern_Alias #-} sem_Pattern_Alias :: (Identifier) -> (Identifier) -> T_Pattern -> T_Pattern sem_Pattern_Alias arg_field_ arg_attr_ arg_pat_ = T_Pattern (return st20) where {-# NOINLINE st20 #-} st20 = let v19 :: T_Pattern_v19 v19 = \ (T_Pattern_vIn19 _lhsIallTypeSigs _lhsIaltAttrs _lhsIcon _lhsIinh _lhsInt _lhsIsyn) -> ( let _patX20 = Control.Monad.Identity.runIdentity (attach_T_Pattern (arg_pat_)) (T_Pattern_vOut19 _patIcopy _patIerrors _patIgathAltAttrs _patIinstVars _patIlocVars _patIpatternAttrs) = inv_Pattern_s20 _patX20 (T_Pattern_vIn19 _patOallTypeSigs _patOaltAttrs _patOcon _patOinh _patOnt _patOsyn) _lhsOgathAltAttrs :: [AltAttr] _lhsOgathAltAttrs = rule252 arg_attr_ arg_field_ _lhsOpatternAttrs :: [(Identifier,Identifier,Bool)] _lhsOpatternAttrs = rule253 arg_attr_ arg_field_ _lhsOlocVars :: [Identifier] _lhsOlocVars = rule254 arg_attr_ arg_field_ _lhsOinstVars :: [Identifier] _lhsOinstVars = rule255 arg_attr_ arg_field_ _lhsOerrors :: Seq Error _lhsOerrors = rule256 _patIerrors _copy = rule257 _patIcopy arg_attr_ arg_field_ _lhsOcopy :: Pattern _lhsOcopy = rule258 _copy _patOallTypeSigs = rule259 _lhsIallTypeSigs _patOaltAttrs = rule260 _lhsIaltAttrs _patOcon = rule261 _lhsIcon _patOinh = rule262 _lhsIinh _patOnt = rule263 _lhsInt _patOsyn = rule264 _lhsIsyn __result_ = T_Pattern_vOut19 _lhsOcopy _lhsOerrors _lhsOgathAltAttrs _lhsOinstVars _lhsOlocVars _lhsOpatternAttrs in __result_ ) in C_Pattern_s20 v19 {-# INLINE rule252 #-} {-# LINE 185 "./src-ag/Order.ag" #-} rule252 = \ attr_ field_ -> {-# LINE 185 "./src-ag/Order.ag" #-} [AltAttr field_ attr_ (field_ == _LOC || field_ == _INST)] {-# LINE 1999 "dist/build/Order.hs"#-} {-# INLINE rule253 #-} {-# LINE 251 "./src-ag/Order.ag" #-} rule253 = \ attr_ field_ -> {-# LINE 251 "./src-ag/Order.ag" #-} [(field_,attr_,(field_ == _LOC || field_ == _INST))] {-# LINE 2005 "dist/build/Order.hs"#-} {-# INLINE rule254 #-} {-# LINE 681 "./src-ag/Order.ag" #-} rule254 = \ attr_ field_ -> {-# LINE 681 "./src-ag/Order.ag" #-} if field_ == _LOC then [attr_] else [] {-# LINE 2013 "dist/build/Order.hs"#-} {-# INLINE rule255 #-} {-# LINE 684 "./src-ag/Order.ag" #-} rule255 = \ attr_ field_ -> {-# LINE 684 "./src-ag/Order.ag" #-} if field_ == _INST then [attr_] else [] {-# LINE 2021 "dist/build/Order.hs"#-} {-# INLINE rule256 #-} rule256 = \ ((_patIerrors) :: Seq Error) -> _patIerrors {-# INLINE rule257 #-} rule257 = \ ((_patIcopy) :: Pattern) attr_ field_ -> Alias field_ attr_ _patIcopy {-# INLINE rule258 #-} rule258 = \ _copy -> _copy {-# INLINE rule259 #-} rule259 = \ ((_lhsIallTypeSigs) :: Map Identifier Type) -> _lhsIallTypeSigs {-# INLINE rule260 #-} rule260 = \ ((_lhsIaltAttrs) :: Map AltAttr Vertex) -> _lhsIaltAttrs {-# INLINE rule261 #-} rule261 = \ ((_lhsIcon) :: Identifier) -> _lhsIcon {-# INLINE rule262 #-} rule262 = \ ((_lhsIinh) :: Attributes) -> _lhsIinh {-# INLINE rule263 #-} rule263 = \ ((_lhsInt) :: Identifier) -> _lhsInt {-# INLINE rule264 #-} rule264 = \ ((_lhsIsyn) :: Attributes) -> _lhsIsyn {-# NOINLINE sem_Pattern_Irrefutable #-} sem_Pattern_Irrefutable :: T_Pattern -> T_Pattern sem_Pattern_Irrefutable arg_pat_ = T_Pattern (return st20) where {-# NOINLINE st20 #-} st20 = let v19 :: T_Pattern_v19 v19 = \ (T_Pattern_vIn19 _lhsIallTypeSigs _lhsIaltAttrs _lhsIcon _lhsIinh _lhsInt _lhsIsyn) -> ( let _patX20 = Control.Monad.Identity.runIdentity (attach_T_Pattern (arg_pat_)) (T_Pattern_vOut19 _patIcopy _patIerrors _patIgathAltAttrs _patIinstVars _patIlocVars _patIpatternAttrs) = inv_Pattern_s20 _patX20 (T_Pattern_vIn19 _patOallTypeSigs _patOaltAttrs _patOcon _patOinh _patOnt _patOsyn) _lhsOerrors :: Seq Error _lhsOerrors = rule265 _patIerrors _lhsOgathAltAttrs :: [AltAttr] _lhsOgathAltAttrs = rule266 _patIgathAltAttrs _lhsOinstVars :: [Identifier] _lhsOinstVars = rule267 _patIinstVars _lhsOlocVars :: [Identifier] _lhsOlocVars = rule268 _patIlocVars _lhsOpatternAttrs :: [(Identifier,Identifier,Bool)] _lhsOpatternAttrs = rule269 _patIpatternAttrs _copy = rule270 _patIcopy _lhsOcopy :: Pattern _lhsOcopy = rule271 _copy _patOallTypeSigs = rule272 _lhsIallTypeSigs _patOaltAttrs = rule273 _lhsIaltAttrs _patOcon = rule274 _lhsIcon _patOinh = rule275 _lhsIinh _patOnt = rule276 _lhsInt _patOsyn = rule277 _lhsIsyn __result_ = T_Pattern_vOut19 _lhsOcopy _lhsOerrors _lhsOgathAltAttrs _lhsOinstVars _lhsOlocVars _lhsOpatternAttrs in __result_ ) in C_Pattern_s20 v19 {-# INLINE rule265 #-} rule265 = \ ((_patIerrors) :: Seq Error) -> _patIerrors {-# INLINE rule266 #-} rule266 = \ ((_patIgathAltAttrs) :: [AltAttr]) -> _patIgathAltAttrs {-# INLINE rule267 #-} rule267 = \ ((_patIinstVars) :: [Identifier]) -> _patIinstVars {-# INLINE rule268 #-} rule268 = \ ((_patIlocVars) :: [Identifier]) -> _patIlocVars {-# INLINE rule269 #-} rule269 = \ ((_patIpatternAttrs) :: [(Identifier,Identifier,Bool)]) -> _patIpatternAttrs {-# INLINE rule270 #-} rule270 = \ ((_patIcopy) :: Pattern) -> Irrefutable _patIcopy {-# INLINE rule271 #-} rule271 = \ _copy -> _copy {-# INLINE rule272 #-} rule272 = \ ((_lhsIallTypeSigs) :: Map Identifier Type) -> _lhsIallTypeSigs {-# INLINE rule273 #-} rule273 = \ ((_lhsIaltAttrs) :: Map AltAttr Vertex) -> _lhsIaltAttrs {-# INLINE rule274 #-} rule274 = \ ((_lhsIcon) :: Identifier) -> _lhsIcon {-# INLINE rule275 #-} rule275 = \ ((_lhsIinh) :: Attributes) -> _lhsIinh {-# INLINE rule276 #-} rule276 = \ ((_lhsInt) :: Identifier) -> _lhsInt {-# INLINE rule277 #-} rule277 = \ ((_lhsIsyn) :: Attributes) -> _lhsIsyn {-# NOINLINE sem_Pattern_Underscore #-} sem_Pattern_Underscore :: (Pos) -> T_Pattern sem_Pattern_Underscore arg_pos_ = T_Pattern (return st20) where {-# NOINLINE st20 #-} st20 = let v19 :: T_Pattern_v19 v19 = \ (T_Pattern_vIn19 _lhsIallTypeSigs _lhsIaltAttrs _lhsIcon _lhsIinh _lhsInt _lhsIsyn) -> ( let _lhsOerrors :: Seq Error _lhsOerrors = rule278 () _lhsOgathAltAttrs :: [AltAttr] _lhsOgathAltAttrs = rule279 () _lhsOinstVars :: [Identifier] _lhsOinstVars = rule280 () _lhsOlocVars :: [Identifier] _lhsOlocVars = rule281 () _lhsOpatternAttrs :: [(Identifier,Identifier,Bool)] _lhsOpatternAttrs = rule282 () _copy = rule283 arg_pos_ _lhsOcopy :: Pattern _lhsOcopy = rule284 _copy __result_ = T_Pattern_vOut19 _lhsOcopy _lhsOerrors _lhsOgathAltAttrs _lhsOinstVars _lhsOlocVars _lhsOpatternAttrs in __result_ ) in C_Pattern_s20 v19 {-# INLINE rule278 #-} rule278 = \ (_ :: ()) -> Seq.empty {-# INLINE rule279 #-} rule279 = \ (_ :: ()) -> [] {-# INLINE rule280 #-} rule280 = \ (_ :: ()) -> [] {-# INLINE rule281 #-} rule281 = \ (_ :: ()) -> [] {-# INLINE rule282 #-} rule282 = \ (_ :: ()) -> [] {-# INLINE rule283 #-} rule283 = \ pos_ -> Underscore pos_ {-# INLINE rule284 #-} rule284 = \ _copy -> _copy -- Patterns ---------------------------------------------------- -- wrapper data Inh_Patterns = Inh_Patterns { allTypeSigs_Inh_Patterns :: (Map Identifier Type), altAttrs_Inh_Patterns :: (Map AltAttr Vertex), con_Inh_Patterns :: (Identifier), inh_Inh_Patterns :: (Attributes), nt_Inh_Patterns :: (Identifier), syn_Inh_Patterns :: (Attributes) } data Syn_Patterns = Syn_Patterns { copy_Syn_Patterns :: (Patterns), errors_Syn_Patterns :: (Seq Error), gathAltAttrs_Syn_Patterns :: ([AltAttr]), instVars_Syn_Patterns :: ([Identifier]), locVars_Syn_Patterns :: ([Identifier]), patternAttrs_Syn_Patterns :: ([(Identifier,Identifier,Bool)]) } {-# INLINABLE wrap_Patterns #-} wrap_Patterns :: T_Patterns -> Inh_Patterns -> (Syn_Patterns ) wrap_Patterns (T_Patterns act) (Inh_Patterns _lhsIallTypeSigs _lhsIaltAttrs _lhsIcon _lhsIinh _lhsInt _lhsIsyn) = Control.Monad.Identity.runIdentity ( do sem <- act let arg = T_Patterns_vIn22 _lhsIallTypeSigs _lhsIaltAttrs _lhsIcon _lhsIinh _lhsInt _lhsIsyn (T_Patterns_vOut22 _lhsOcopy _lhsOerrors _lhsOgathAltAttrs _lhsOinstVars _lhsOlocVars _lhsOpatternAttrs) <- return (inv_Patterns_s23 sem arg) return (Syn_Patterns _lhsOcopy _lhsOerrors _lhsOgathAltAttrs _lhsOinstVars _lhsOlocVars _lhsOpatternAttrs) ) -- cata {-# NOINLINE sem_Patterns #-} sem_Patterns :: Patterns -> T_Patterns sem_Patterns list = Prelude.foldr sem_Patterns_Cons sem_Patterns_Nil (Prelude.map sem_Pattern list) -- semantic domain newtype T_Patterns = T_Patterns { attach_T_Patterns :: Identity (T_Patterns_s23 ) } newtype T_Patterns_s23 = C_Patterns_s23 { inv_Patterns_s23 :: (T_Patterns_v22 ) } data T_Patterns_s24 = C_Patterns_s24 type T_Patterns_v22 = (T_Patterns_vIn22 ) -> (T_Patterns_vOut22 ) data T_Patterns_vIn22 = T_Patterns_vIn22 (Map Identifier Type) (Map AltAttr Vertex) (Identifier) (Attributes) (Identifier) (Attributes) data T_Patterns_vOut22 = T_Patterns_vOut22 (Patterns) (Seq Error) ([AltAttr]) ([Identifier]) ([Identifier]) ([(Identifier,Identifier,Bool)]) {-# NOINLINE sem_Patterns_Cons #-} sem_Patterns_Cons :: T_Pattern -> T_Patterns -> T_Patterns sem_Patterns_Cons arg_hd_ arg_tl_ = T_Patterns (return st23) where {-# NOINLINE st23 #-} st23 = let v22 :: T_Patterns_v22 v22 = \ (T_Patterns_vIn22 _lhsIallTypeSigs _lhsIaltAttrs _lhsIcon _lhsIinh _lhsInt _lhsIsyn) -> ( let _hdX20 = Control.Monad.Identity.runIdentity (attach_T_Pattern (arg_hd_)) _tlX23 = Control.Monad.Identity.runIdentity (attach_T_Patterns (arg_tl_)) (T_Pattern_vOut19 _hdIcopy _hdIerrors _hdIgathAltAttrs _hdIinstVars _hdIlocVars _hdIpatternAttrs) = inv_Pattern_s20 _hdX20 (T_Pattern_vIn19 _hdOallTypeSigs _hdOaltAttrs _hdOcon _hdOinh _hdOnt _hdOsyn) (T_Patterns_vOut22 _tlIcopy _tlIerrors _tlIgathAltAttrs _tlIinstVars _tlIlocVars _tlIpatternAttrs) = inv_Patterns_s23 _tlX23 (T_Patterns_vIn22 _tlOallTypeSigs _tlOaltAttrs _tlOcon _tlOinh _tlOnt _tlOsyn) _lhsOerrors :: Seq Error _lhsOerrors = rule285 _hdIerrors _tlIerrors _lhsOgathAltAttrs :: [AltAttr] _lhsOgathAltAttrs = rule286 _hdIgathAltAttrs _tlIgathAltAttrs _lhsOinstVars :: [Identifier] _lhsOinstVars = rule287 _hdIinstVars _tlIinstVars _lhsOlocVars :: [Identifier] _lhsOlocVars = rule288 _hdIlocVars _tlIlocVars _lhsOpatternAttrs :: [(Identifier,Identifier,Bool)] _lhsOpatternAttrs = rule289 _hdIpatternAttrs _tlIpatternAttrs _copy = rule290 _hdIcopy _tlIcopy _lhsOcopy :: Patterns _lhsOcopy = rule291 _copy _hdOallTypeSigs = rule292 _lhsIallTypeSigs _hdOaltAttrs = rule293 _lhsIaltAttrs _hdOcon = rule294 _lhsIcon _hdOinh = rule295 _lhsIinh _hdOnt = rule296 _lhsInt _hdOsyn = rule297 _lhsIsyn _tlOallTypeSigs = rule298 _lhsIallTypeSigs _tlOaltAttrs = rule299 _lhsIaltAttrs _tlOcon = rule300 _lhsIcon _tlOinh = rule301 _lhsIinh _tlOnt = rule302 _lhsInt _tlOsyn = rule303 _lhsIsyn __result_ = T_Patterns_vOut22 _lhsOcopy _lhsOerrors _lhsOgathAltAttrs _lhsOinstVars _lhsOlocVars _lhsOpatternAttrs in __result_ ) in C_Patterns_s23 v22 {-# INLINE rule285 #-} rule285 = \ ((_hdIerrors) :: Seq Error) ((_tlIerrors) :: Seq Error) -> _hdIerrors Seq.>< _tlIerrors {-# INLINE rule286 #-} rule286 = \ ((_hdIgathAltAttrs) :: [AltAttr]) ((_tlIgathAltAttrs) :: [AltAttr]) -> _hdIgathAltAttrs ++ _tlIgathAltAttrs {-# INLINE rule287 #-} rule287 = \ ((_hdIinstVars) :: [Identifier]) ((_tlIinstVars) :: [Identifier]) -> _hdIinstVars ++ _tlIinstVars {-# INLINE rule288 #-} rule288 = \ ((_hdIlocVars) :: [Identifier]) ((_tlIlocVars) :: [Identifier]) -> _hdIlocVars ++ _tlIlocVars {-# INLINE rule289 #-} rule289 = \ ((_hdIpatternAttrs) :: [(Identifier,Identifier,Bool)]) ((_tlIpatternAttrs) :: [(Identifier,Identifier,Bool)]) -> _hdIpatternAttrs ++ _tlIpatternAttrs {-# INLINE rule290 #-} rule290 = \ ((_hdIcopy) :: Pattern) ((_tlIcopy) :: Patterns) -> (:) _hdIcopy _tlIcopy {-# INLINE rule291 #-} rule291 = \ _copy -> _copy {-# INLINE rule292 #-} rule292 = \ ((_lhsIallTypeSigs) :: Map Identifier Type) -> _lhsIallTypeSigs {-# INLINE rule293 #-} rule293 = \ ((_lhsIaltAttrs) :: Map AltAttr Vertex) -> _lhsIaltAttrs {-# INLINE rule294 #-} rule294 = \ ((_lhsIcon) :: Identifier) -> _lhsIcon {-# INLINE rule295 #-} rule295 = \ ((_lhsIinh) :: Attributes) -> _lhsIinh {-# INLINE rule296 #-} rule296 = \ ((_lhsInt) :: Identifier) -> _lhsInt {-# INLINE rule297 #-} rule297 = \ ((_lhsIsyn) :: Attributes) -> _lhsIsyn {-# INLINE rule298 #-} rule298 = \ ((_lhsIallTypeSigs) :: Map Identifier Type) -> _lhsIallTypeSigs {-# INLINE rule299 #-} rule299 = \ ((_lhsIaltAttrs) :: Map AltAttr Vertex) -> _lhsIaltAttrs {-# INLINE rule300 #-} rule300 = \ ((_lhsIcon) :: Identifier) -> _lhsIcon {-# INLINE rule301 #-} rule301 = \ ((_lhsIinh) :: Attributes) -> _lhsIinh {-# INLINE rule302 #-} rule302 = \ ((_lhsInt) :: Identifier) -> _lhsInt {-# INLINE rule303 #-} rule303 = \ ((_lhsIsyn) :: Attributes) -> _lhsIsyn {-# NOINLINE sem_Patterns_Nil #-} sem_Patterns_Nil :: T_Patterns sem_Patterns_Nil = T_Patterns (return st23) where {-# NOINLINE st23 #-} st23 = let v22 :: T_Patterns_v22 v22 = \ (T_Patterns_vIn22 _lhsIallTypeSigs _lhsIaltAttrs _lhsIcon _lhsIinh _lhsInt _lhsIsyn) -> ( let _lhsOerrors :: Seq Error _lhsOerrors = rule304 () _lhsOgathAltAttrs :: [AltAttr] _lhsOgathAltAttrs = rule305 () _lhsOinstVars :: [Identifier] _lhsOinstVars = rule306 () _lhsOlocVars :: [Identifier] _lhsOlocVars = rule307 () _lhsOpatternAttrs :: [(Identifier,Identifier,Bool)] _lhsOpatternAttrs = rule308 () _copy = rule309 () _lhsOcopy :: Patterns _lhsOcopy = rule310 _copy __result_ = T_Patterns_vOut22 _lhsOcopy _lhsOerrors _lhsOgathAltAttrs _lhsOinstVars _lhsOlocVars _lhsOpatternAttrs in __result_ ) in C_Patterns_s23 v22 {-# INLINE rule304 #-} rule304 = \ (_ :: ()) -> Seq.empty {-# INLINE rule305 #-} rule305 = \ (_ :: ()) -> [] {-# INLINE rule306 #-} rule306 = \ (_ :: ()) -> [] {-# INLINE rule307 #-} rule307 = \ (_ :: ()) -> [] {-# INLINE rule308 #-} rule308 = \ (_ :: ()) -> [] {-# INLINE rule309 #-} rule309 = \ (_ :: ()) -> [] {-# INLINE rule310 #-} rule310 = \ _copy -> _copy -- Production -------------------------------------------------- -- wrapper data Inh_Production = Inh_Production { allnts_Inh_Production :: ([Identifier]), aroundMap_Inh_Production :: (Map ConstructorIdent (Map Identifier [Expression])), cVisitsMap_Inh_Production :: (CVisitsMap), inh_Inh_Production :: (Attributes), inhMap_Inh_Production :: (Map Identifier Attributes), manualAttrDepMap_Inh_Production :: (AttrOrderMap), mergeMap_Inh_Production :: (Map ConstructorIdent (Map Identifier (Identifier,[Identifier]))), nt_Inh_Production :: (Identifier), o_case_Inh_Production :: (Bool), o_cata_Inh_Production :: (Bool), o_dovisit_Inh_Production :: (Bool), o_newtypes_Inh_Production :: (Bool), o_rename_Inh_Production :: (Bool), o_sem_Inh_Production :: (Bool), o_sig_Inh_Production :: (Bool), o_unbox_Inh_Production :: (Bool), o_wantvisit_Inh_Production :: (Bool), prefix_Inh_Production :: (String), syn_Inh_Production :: (Attributes), synMap_Inh_Production :: (Map Identifier Attributes), vcount_Inh_Production :: (Int) } data Syn_Production = Syn_Production { additionalDep_Syn_Production :: (Seq Edge), aroundDep_Syn_Production :: (Seq Edge), cProduction_Syn_Production :: (CProduction), cons_Syn_Production :: ([ConstructorIdent]), directDep_Syn_Production :: (Seq Edge), errors_Syn_Production :: (Seq Error), instDep_Syn_Production :: (Seq Edge), mergeDep_Syn_Production :: (Seq Edge), nAutoRules_Syn_Production :: (Int), nExplicitRules_Syn_Production :: (Int), rules_Syn_Production :: (Seq (Vertex,CRule)), vcount_Syn_Production :: (Int) } {-# INLINABLE wrap_Production #-} wrap_Production :: T_Production -> Inh_Production -> (Syn_Production ) wrap_Production (T_Production act) (Inh_Production _lhsIallnts _lhsIaroundMap _lhsIcVisitsMap _lhsIinh _lhsIinhMap _lhsImanualAttrDepMap _lhsImergeMap _lhsInt _lhsIo_case _lhsIo_cata _lhsIo_dovisit _lhsIo_newtypes _lhsIo_rename _lhsIo_sem _lhsIo_sig _lhsIo_unbox _lhsIo_wantvisit _lhsIprefix _lhsIsyn _lhsIsynMap _lhsIvcount) = Control.Monad.Identity.runIdentity ( do sem <- act let arg = T_Production_vIn25 _lhsIallnts _lhsIaroundMap _lhsIcVisitsMap _lhsIinh _lhsIinhMap _lhsImanualAttrDepMap _lhsImergeMap _lhsInt _lhsIo_case _lhsIo_cata _lhsIo_dovisit _lhsIo_newtypes _lhsIo_rename _lhsIo_sem _lhsIo_sig _lhsIo_unbox _lhsIo_wantvisit _lhsIprefix _lhsIsyn _lhsIsynMap _lhsIvcount (T_Production_vOut25 _lhsOadditionalDep _lhsOaroundDep _lhsOcProduction _lhsOcons _lhsOdirectDep _lhsOerrors _lhsOinstDep _lhsOmergeDep _lhsOnAutoRules _lhsOnExplicitRules _lhsOrules _lhsOvcount) <- return (inv_Production_s26 sem arg) return (Syn_Production _lhsOadditionalDep _lhsOaroundDep _lhsOcProduction _lhsOcons _lhsOdirectDep _lhsOerrors _lhsOinstDep _lhsOmergeDep _lhsOnAutoRules _lhsOnExplicitRules _lhsOrules _lhsOvcount) ) -- cata {-# INLINE sem_Production #-} sem_Production :: Production -> T_Production sem_Production ( Production con_ params_ constraints_ children_ rules_ typeSigs_ macro_ ) = sem_Production_Production con_ params_ constraints_ ( sem_Children children_ ) ( sem_Rules rules_ ) ( sem_TypeSigs typeSigs_ ) macro_ -- semantic domain newtype T_Production = T_Production { attach_T_Production :: Identity (T_Production_s26 ) } newtype T_Production_s26 = C_Production_s26 { inv_Production_s26 :: (T_Production_v25 ) } data T_Production_s27 = C_Production_s27 type T_Production_v25 = (T_Production_vIn25 ) -> (T_Production_vOut25 ) data T_Production_vIn25 = T_Production_vIn25 ([Identifier]) (Map ConstructorIdent (Map Identifier [Expression])) (CVisitsMap) (Attributes) (Map Identifier Attributes) (AttrOrderMap) (Map ConstructorIdent (Map Identifier (Identifier,[Identifier]))) (Identifier) (Bool) (Bool) (Bool) (Bool) (Bool) (Bool) (Bool) (Bool) (Bool) (String) (Attributes) (Map Identifier Attributes) (Int) data T_Production_vOut25 = T_Production_vOut25 (Seq Edge) (Seq Edge) (CProduction) ([ConstructorIdent]) (Seq Edge) (Seq Error) (Seq Edge) (Seq Edge) (Int) (Int) (Seq (Vertex,CRule)) (Int) {-# NOINLINE sem_Production_Production #-} sem_Production_Production :: (ConstructorIdent) -> ([Identifier]) -> ([Type]) -> T_Children -> T_Rules -> T_TypeSigs -> (MaybeMacro) -> T_Production sem_Production_Production arg_con_ _ _ arg_children_ arg_rules_ arg_typeSigs_ _ = T_Production (return st26) where {-# NOINLINE st26 #-} st26 = let v25 :: T_Production_v25 v25 = \ (T_Production_vIn25 _lhsIallnts _lhsIaroundMap _lhsIcVisitsMap _lhsIinh _lhsIinhMap _lhsImanualAttrDepMap _lhsImergeMap _lhsInt _lhsIo_case _lhsIo_cata _lhsIo_dovisit _lhsIo_newtypes _lhsIo_rename _lhsIo_sem _lhsIo_sig _lhsIo_unbox _lhsIo_wantvisit _lhsIprefix _lhsIsyn _lhsIsynMap _lhsIvcount) -> ( let _childrenX5 = Control.Monad.Identity.runIdentity (attach_T_Children (arg_children_)) _rulesX35 = Control.Monad.Identity.runIdentity (attach_T_Rules (arg_rules_)) _typeSigsX41 = Control.Monad.Identity.runIdentity (attach_T_TypeSigs (arg_typeSigs_)) (T_Children_vOut4 _childrenIattributes _childrenIcollectChildrenInhs _childrenIcollectChildrenSyns _childrenIerrors _childrenIfields _childrenIgathAltAttrs _childrenIgathRules _childrenIinhs _childrenInts _childrenIsinglevisits _childrenIterminals) = inv_Children_s5 _childrenX5 (T_Children_vIn4 _childrenOallfields _childrenOallnts _childrenOattrs _childrenOcon _childrenOinh _childrenOinhMap _childrenOmergeMap _childrenOnt _childrenOo_unbox _childrenOsyn _childrenOsynMap) (T_Rules_vOut34 _rulesIdirectDep _rulesIerrors _rulesIgathAltAttrs _rulesIgathRules _rulesIinstDep _rulesIinstVars _rulesIlocVars _rulesInAutoRules _rulesInExplicitRules) = inv_Rules_s35 _rulesX35 (T_Rules_vIn34 _rulesOallTypeSigs _rulesOallfields _rulesOallnts _rulesOaltAttrs _rulesOattrs _rulesOchildInhs _rulesOchildNts _rulesOcon _rulesOinh _rulesOinhsOfChildren _rulesOmergeMap _rulesOnt _rulesOo_case _rulesOo_cata _rulesOo_dovisit _rulesOo_newtypes _rulesOo_rename _rulesOo_sem _rulesOo_sig _rulesOo_wantvisit _rulesOprefix _rulesOsyn _rulesOsynsOfChildren) (T_TypeSigs_vOut40 _typeSigsItypeSigs) = inv_TypeSigs_s41 _typeSigsX41 (T_TypeSigs_vIn40 _typeSigsOtypeSigs) _childrenOcon = rule311 arg_con_ _rulesOcon = rule312 arg_con_ _gathAltAttrs = rule313 _childrenIgathAltAttrs _lhsIinh _rulesIgathAltAttrs _altAttrs = rule314 _gathAltAttrs _lhsIvcount _rulesOchildNts = rule315 _childrenInts _rulesOchildInhs = rule316 _childrenIinhs _inhRules = rule317 _lhsIinh _lhsInt arg_con_ _gathRules = rule318 _childrenIgathRules _inhRules _rulesIgathRules _lhsOrules :: Seq (Vertex,CRule) _lhsOrules = rule319 _gathRules _lhsIvcount _lhsOvcount :: Int _lhsOvcount = rule320 _gathRules _lhsIvcount _manualDeps = rule321 _lhsImanualAttrDepMap _lhsInt arg_con_ _lhsOadditionalDep :: Seq Edge _lhsOadditionalDep = rule322 _altAttrs _manualDeps _rulesOsynsOfChildren = rule323 _childrenIcollectChildrenSyns _rulesOinhsOfChildren = rule324 _childrenIcollectChildrenInhs _mergeMap = rule325 _lhsImergeMap arg_con_ _lhsOmergeDep :: Seq Edge _lhsOmergeDep = rule326 _mergeDep1 _mergeDep2 _mergeDep1 = rule327 _altAttrs _childrenIcollectChildrenSyns _mergeMap _mergeDep2 = rule328 _altAttrs _childrenIcollectChildrenSyns _mergeMap _aroundMap = rule329 _lhsIaroundMap arg_con_ _aroundDep1 = rule330 _altAttrs _aroundMap _childrenIcollectChildrenSyns _aroundDep2 = rule331 _altAttrs _aroundMap _childrenIcollectChildrenInhs _lhsOaroundDep :: Seq Edge _lhsOaroundDep = rule332 _aroundDep1 _aroundDep2 _lhsOcons :: [ConstructorIdent] _lhsOcons = rule333 arg_con_ _typeSigsOtypeSigs = rule334 () _rulesOallTypeSigs = rule335 _typeSigsItypeSigs _cVisits = rule336 _childrenIsinglevisits _gathRules _lhsIcVisitsMap _lhsIinh _lhsInt _lhsIo_dovisit _lhsIsyn arg_con_ _lhsOcProduction :: CProduction _lhsOcProduction = rule337 _cVisits _childrenIfields _childrenIterminals arg_con_ _allfields = rule338 _childrenIfields _attrs = rule339 _childrenIattributes _inhnames _rulesIinstVars _rulesIlocVars _inhnames = rule340 _lhsIinh _synnames = rule341 _lhsIsyn _lhsOdirectDep :: Seq Edge _lhsOdirectDep = rule342 _rulesIdirectDep _lhsOerrors :: Seq Error _lhsOerrors = rule343 _childrenIerrors _rulesIerrors _lhsOinstDep :: Seq Edge _lhsOinstDep = rule344 _rulesIinstDep _lhsOnAutoRules :: Int _lhsOnAutoRules = rule345 _rulesInAutoRules _lhsOnExplicitRules :: Int _lhsOnExplicitRules = rule346 _rulesInExplicitRules _childrenOallfields = rule347 _allfields _childrenOallnts = rule348 _lhsIallnts _childrenOattrs = rule349 _attrs _childrenOinh = rule350 _lhsIinh _childrenOinhMap = rule351 _lhsIinhMap _childrenOmergeMap = rule352 _mergeMap _childrenOnt = rule353 _lhsInt _childrenOo_unbox = rule354 _lhsIo_unbox _childrenOsyn = rule355 _lhsIsyn _childrenOsynMap = rule356 _lhsIsynMap _rulesOallfields = rule357 _allfields _rulesOallnts = rule358 _lhsIallnts _rulesOaltAttrs = rule359 _altAttrs _rulesOattrs = rule360 _attrs _rulesOinh = rule361 _lhsIinh _rulesOmergeMap = rule362 _mergeMap _rulesOnt = rule363 _lhsInt _rulesOo_case = rule364 _lhsIo_case _rulesOo_cata = rule365 _lhsIo_cata _rulesOo_dovisit = rule366 _lhsIo_dovisit _rulesOo_newtypes = rule367 _lhsIo_newtypes _rulesOo_rename = rule368 _lhsIo_rename _rulesOo_sem = rule369 _lhsIo_sem _rulesOo_sig = rule370 _lhsIo_sig _rulesOo_wantvisit = rule371 _lhsIo_wantvisit _rulesOprefix = rule372 _lhsIprefix _rulesOsyn = rule373 _lhsIsyn __result_ = T_Production_vOut25 _lhsOadditionalDep _lhsOaroundDep _lhsOcProduction _lhsOcons _lhsOdirectDep _lhsOerrors _lhsOinstDep _lhsOmergeDep _lhsOnAutoRules _lhsOnExplicitRules _lhsOrules _lhsOvcount in __result_ ) in C_Production_s26 v25 {-# INLINE rule311 #-} {-# LINE 94 "./src-ag/Order.ag" #-} rule311 = \ con_ -> {-# LINE 94 "./src-ag/Order.ag" #-} con_ {-# LINE 2461 "dist/build/Order.hs"#-} {-# INLINE rule312 #-} {-# LINE 96 "./src-ag/Order.ag" #-} rule312 = \ con_ -> {-# LINE 96 "./src-ag/Order.ag" #-} con_ {-# LINE 2467 "dist/build/Order.hs"#-} {-# INLINE rule313 #-} {-# LINE 173 "./src-ag/Order.ag" #-} rule313 = \ ((_childrenIgathAltAttrs) :: [AltAttr]) ((_lhsIinh) :: Attributes) ((_rulesIgathAltAttrs) :: [AltAttr]) -> {-# LINE 173 "./src-ag/Order.ag" #-} [ AltAttr _LHS inh True | inh <- Map.keys _lhsIinh ] ++ _childrenIgathAltAttrs ++ _rulesIgathAltAttrs {-# LINE 2475 "dist/build/Order.hs"#-} {-# INLINE rule314 #-} {-# LINE 189 "./src-ag/Order.ag" #-} rule314 = \ _gathAltAttrs ((_lhsIvcount) :: Int) -> {-# LINE 189 "./src-ag/Order.ag" #-} Map.fromList (zip _gathAltAttrs [_lhsIvcount..]) {-# LINE 2481 "dist/build/Order.hs"#-} {-# INLINE rule315 #-} {-# LINE 202 "./src-ag/Order.ag" #-} rule315 = \ ((_childrenInts) :: Seq (Identifier,NontermIdent)) -> {-# LINE 202 "./src-ag/Order.ag" #-} Map.fromList (toList _childrenInts) {-# LINE 2487 "dist/build/Order.hs"#-} {-# INLINE rule316 #-} {-# LINE 203 "./src-ag/Order.ag" #-} rule316 = \ ((_childrenIinhs) :: Seq (Identifier,Attributes)) -> {-# LINE 203 "./src-ag/Order.ag" #-} Map.fromList (toList _childrenIinhs) {-# LINE 2493 "dist/build/Order.hs"#-} {-# INLINE rule317 #-} {-# LINE 209 "./src-ag/Order.ag" #-} rule317 = \ ((_lhsIinh) :: Attributes) ((_lhsInt) :: Identifier) con_ -> {-# LINE 209 "./src-ag/Order.ag" #-} [ cRuleLhsInh inh _lhsInt con_ tp | (inh,tp) <- Map.assocs _lhsIinh ] {-# LINE 2499 "dist/build/Order.hs"#-} {-# INLINE rule318 #-} {-# LINE 210 "./src-ag/Order.ag" #-} rule318 = \ ((_childrenIgathRules) :: Seq CRule) _inhRules ((_rulesIgathRules) :: Seq CRule) -> {-# LINE 210 "./src-ag/Order.ag" #-} _inhRules ++ toList (_childrenIgathRules Seq.>< _rulesIgathRules) {-# LINE 2505 "dist/build/Order.hs"#-} {-# INLINE rule319 #-} {-# LINE 262 "./src-ag/Order.ag" #-} rule319 = \ _gathRules ((_lhsIvcount) :: Int) -> {-# LINE 262 "./src-ag/Order.ag" #-} Seq.fromList (zip [_lhsIvcount..] _gathRules) {-# LINE 2511 "dist/build/Order.hs"#-} {-# INLINE rule320 #-} {-# LINE 263 "./src-ag/Order.ag" #-} rule320 = \ _gathRules ((_lhsIvcount) :: Int) -> {-# LINE 263 "./src-ag/Order.ag" #-} _lhsIvcount + length _gathRules {-# LINE 2517 "dist/build/Order.hs"#-} {-# INLINE rule321 #-} {-# LINE 291 "./src-ag/Order.ag" #-} rule321 = \ ((_lhsImanualAttrDepMap) :: AttrOrderMap) ((_lhsInt) :: Identifier) con_ -> {-# LINE 291 "./src-ag/Order.ag" #-} Set.toList $ Map.findWithDefault Set.empty con_ $ Map.findWithDefault Map.empty _lhsInt _lhsImanualAttrDepMap {-# LINE 2523 "dist/build/Order.hs"#-} {-# INLINE rule322 #-} {-# LINE 294 "./src-ag/Order.ag" #-} rule322 = \ _altAttrs _manualDeps -> {-# LINE 294 "./src-ag/Order.ag" #-} Seq.fromList [ (vertex True occA, vertex False occB) | Dependency occA occB <- _manualDeps , let vertex inout (OccAttr child nm) | child == _LOC = findWithErr2 (AltAttr _LOC nm True) _altAttrs | otherwise = findWithErr2 (AltAttr child nm inout) _altAttrs vertex _ (OccRule nm) = findWithErr2 (AltAttr _LOC (Ident ("_rule_" ++ show nm) (getPos nm)) True) _altAttrs ] {-# LINE 2536 "dist/build/Order.hs"#-} {-# INLINE rule323 #-} {-# LINE 340 "./src-ag/Order.ag" #-} rule323 = \ ((_childrenIcollectChildrenSyns) :: Map Identifier Attributes ) -> {-# LINE 340 "./src-ag/Order.ag" #-} _childrenIcollectChildrenSyns {-# LINE 2542 "dist/build/Order.hs"#-} {-# INLINE rule324 #-} {-# LINE 341 "./src-ag/Order.ag" #-} rule324 = \ ((_childrenIcollectChildrenInhs) :: Map Identifier Attributes ) -> {-# LINE 341 "./src-ag/Order.ag" #-} _childrenIcollectChildrenInhs {-# LINE 2548 "dist/build/Order.hs"#-} {-# INLINE rule325 #-} {-# LINE 359 "./src-ag/Order.ag" #-} rule325 = \ ((_lhsImergeMap) :: Map ConstructorIdent (Map Identifier (Identifier,[Identifier]))) con_ -> {-# LINE 359 "./src-ag/Order.ag" #-} Map.findWithDefault Map.empty con_ _lhsImergeMap {-# LINE 2554 "dist/build/Order.hs"#-} {-# INLINE rule326 #-} {-# LINE 370 "./src-ag/Order.ag" #-} rule326 = \ _mergeDep1 _mergeDep2 -> {-# LINE 370 "./src-ag/Order.ag" #-} _mergeDep1 Seq.>< _mergeDep2 {-# LINE 2560 "dist/build/Order.hs"#-} {-# INLINE rule327 #-} {-# LINE 372 "./src-ag/Order.ag" #-} rule327 = \ _altAttrs ((_childrenIcollectChildrenSyns) :: Map Identifier Attributes ) _mergeMap -> {-# LINE 372 "./src-ag/Order.ag" #-} Seq.fromList $ [ (childVert, synVert) | childNm <- Map.keys _mergeMap , synNm <- Map.keys (findWithErr2 childNm _childrenIcollectChildrenSyns) , let childNm' = Ident (show childNm ++ "_merge") (getPos childNm) childAttr = AltAttr _LOC childNm' True synAttr = AltAttr childNm synNm True childVert = findWithErr2 childAttr _altAttrs synVert = findWithErr2 synAttr _altAttrs ] {-# LINE 2575 "dist/build/Order.hs"#-} {-# INLINE rule328 #-} {-# LINE 383 "./src-ag/Order.ag" #-} rule328 = \ _altAttrs ((_childrenIcollectChildrenSyns) :: Map Identifier Attributes ) _mergeMap -> {-# LINE 383 "./src-ag/Order.ag" #-} Seq.fromList $ [ (mergedVert, sourceVert) | (childNm, (_,cs)) <- Map.assocs _mergeMap , c <- cs , synNm <- Map.keys (findWithErr2 childNm _childrenIcollectChildrenSyns) , let sourceAttr = AltAttr childNm synNm True mergedAttr = AltAttr c synNm True sourceVert = findWithErr2 sourceAttr _altAttrs mergedVert = findWithErr2 mergedAttr _altAttrs ] {-# LINE 2590 "dist/build/Order.hs"#-} {-# INLINE rule329 #-} {-# LINE 412 "./src-ag/Order.ag" #-} rule329 = \ ((_lhsIaroundMap) :: Map ConstructorIdent (Map Identifier [Expression])) con_ -> {-# LINE 412 "./src-ag/Order.ag" #-} Map.findWithDefault Map.empty con_ _lhsIaroundMap {-# LINE 2596 "dist/build/Order.hs"#-} {-# INLINE rule330 #-} {-# LINE 420 "./src-ag/Order.ag" #-} rule330 = \ _altAttrs _aroundMap ((_childrenIcollectChildrenSyns) :: Map Identifier Attributes ) -> {-# LINE 420 "./src-ag/Order.ag" #-} Seq.fromList $ [ (childVert, synVert) | childNm <- Map.keys _aroundMap , synNm <- Map.keys (findWithErr2 childNm _childrenIcollectChildrenSyns) , let childNm' = Ident (show childNm ++ "_around") (getPos childNm) childAttr = AltAttr _LOC childNm' True synAttr = AltAttr childNm synNm True childVert = findWithErr2 childAttr _altAttrs synVert = findWithErr2 synAttr _altAttrs ] {-# LINE 2611 "dist/build/Order.hs"#-} {-# INLINE rule331 #-} {-# LINE 431 "./src-ag/Order.ag" #-} rule331 = \ _altAttrs _aroundMap ((_childrenIcollectChildrenInhs) :: Map Identifier Attributes ) -> {-# LINE 431 "./src-ag/Order.ag" #-} Seq.fromList $ [ (childVert, inhVert) | childNm <- Map.keys _aroundMap , inhNm <- Map.keys (findWithErr2 childNm _childrenIcollectChildrenInhs) , let childNm' = Ident (show childNm ++ "_around") (getPos childNm) childAttr = AltAttr _LOC childNm' True inhAttr = AltAttr childNm inhNm False childVert = findWithErr2 childAttr _altAttrs inhVert = findWithErr2 inhAttr _altAttrs ] {-# LINE 2626 "dist/build/Order.hs"#-} {-# INLINE rule332 #-} {-# LINE 441 "./src-ag/Order.ag" #-} rule332 = \ _aroundDep1 _aroundDep2 -> {-# LINE 441 "./src-ag/Order.ag" #-} _aroundDep1 Seq.>< _aroundDep2 {-# LINE 2632 "dist/build/Order.hs"#-} {-# INLINE rule333 #-} {-# LINE 523 "./src-ag/Order.ag" #-} rule333 = \ con_ -> {-# LINE 523 "./src-ag/Order.ag" #-} [con_] {-# LINE 2638 "dist/build/Order.hs"#-} {-# INLINE rule334 #-} {-# LINE 530 "./src-ag/Order.ag" #-} rule334 = \ (_ :: ()) -> {-# LINE 530 "./src-ag/Order.ag" #-} Map.empty {-# LINE 2644 "dist/build/Order.hs"#-} {-# INLINE rule335 #-} {-# LINE 536 "./src-ag/Order.ag" #-} rule335 = \ ((_typeSigsItypeSigs) :: Map Identifier Type) -> {-# LINE 536 "./src-ag/Order.ag" #-} _typeSigsItypeSigs {-# LINE 2650 "dist/build/Order.hs"#-} {-# INLINE rule336 #-} {-# LINE 604 "./src-ag/Order.ag" #-} rule336 = \ ((_childrenIsinglevisits) :: [CRule]) _gathRules ((_lhsIcVisitsMap) :: CVisitsMap) ((_lhsIinh) :: Attributes) ((_lhsInt) :: Identifier) ((_lhsIo_dovisit) :: Bool) ((_lhsIsyn) :: Attributes) con_ -> {-# LINE 604 "./src-ag/Order.ag" #-} if _lhsIo_dovisit then let prodsVisitsMap = findWithErr1 "Production.cVisits.nt" _lhsInt _lhsIcVisitsMap visits = findWithErr1 "Production.cVisits.con" con_ prodsVisitsMap in visits else let vss = nubBy eqCRuleDefines _gathRules ++ _childrenIsinglevisits in [CVisit _lhsIinh _lhsIsyn vss [] False] {-# LINE 2661 "dist/build/Order.hs"#-} {-# INLINE rule337 #-} {-# LINE 630 "./src-ag/Order.ag" #-} rule337 = \ _cVisits ((_childrenIfields) :: [(Identifier,Type,ChildKind)]) ((_childrenIterminals) :: [Identifier]) con_ -> {-# LINE 630 "./src-ag/Order.ag" #-} CProduction con_ _cVisits _childrenIfields _childrenIterminals {-# LINE 2667 "dist/build/Order.hs"#-} {-# INLINE rule338 #-} {-# LINE 658 "./src-ag/Order.ag" #-} rule338 = \ ((_childrenIfields) :: [(Identifier,Type,ChildKind)]) -> {-# LINE 658 "./src-ag/Order.ag" #-} _childrenIfields {-# LINE 2673 "dist/build/Order.hs"#-} {-# INLINE rule339 #-} {-# LINE 659 "./src-ag/Order.ag" #-} rule339 = \ ((_childrenIattributes) :: [(Identifier,Attributes,Attributes)]) _inhnames ((_rulesIinstVars) :: [Identifier]) ((_rulesIlocVars) :: [Identifier]) -> {-# LINE 659 "./src-ag/Order.ag" #-} map ((,) _LOC) _rulesIlocVars ++ map ((,) _INST) _rulesIinstVars ++ map ((,) _LHS) _inhnames ++ concat [map ((,) nm) (Map.keys as) | (nm,_,as) <- _childrenIattributes] {-# LINE 2682 "dist/build/Order.hs"#-} {-# INLINE rule340 #-} {-# LINE 663 "./src-ag/Order.ag" #-} rule340 = \ ((_lhsIinh) :: Attributes) -> {-# LINE 663 "./src-ag/Order.ag" #-} Map.keys _lhsIinh {-# LINE 2688 "dist/build/Order.hs"#-} {-# INLINE rule341 #-} {-# LINE 664 "./src-ag/Order.ag" #-} rule341 = \ ((_lhsIsyn) :: Attributes) -> {-# LINE 664 "./src-ag/Order.ag" #-} Map.keys _lhsIsyn {-# LINE 2694 "dist/build/Order.hs"#-} {-# INLINE rule342 #-} rule342 = \ ((_rulesIdirectDep) :: Seq Edge) -> _rulesIdirectDep {-# INLINE rule343 #-} rule343 = \ ((_childrenIerrors) :: Seq Error) ((_rulesIerrors) :: Seq Error) -> _childrenIerrors Seq.>< _rulesIerrors {-# INLINE rule344 #-} rule344 = \ ((_rulesIinstDep) :: Seq Edge) -> _rulesIinstDep {-# INLINE rule345 #-} rule345 = \ ((_rulesInAutoRules) :: Int) -> _rulesInAutoRules {-# INLINE rule346 #-} rule346 = \ ((_rulesInExplicitRules) :: Int) -> _rulesInExplicitRules {-# INLINE rule347 #-} rule347 = \ _allfields -> _allfields {-# INLINE rule348 #-} rule348 = \ ((_lhsIallnts) :: [Identifier]) -> _lhsIallnts {-# INLINE rule349 #-} rule349 = \ _attrs -> _attrs {-# INLINE rule350 #-} rule350 = \ ((_lhsIinh) :: Attributes) -> _lhsIinh {-# INLINE rule351 #-} rule351 = \ ((_lhsIinhMap) :: Map Identifier Attributes) -> _lhsIinhMap {-# INLINE rule352 #-} rule352 = \ _mergeMap -> _mergeMap {-# INLINE rule353 #-} rule353 = \ ((_lhsInt) :: Identifier) -> _lhsInt {-# INLINE rule354 #-} rule354 = \ ((_lhsIo_unbox) :: Bool) -> _lhsIo_unbox {-# INLINE rule355 #-} rule355 = \ ((_lhsIsyn) :: Attributes) -> _lhsIsyn {-# INLINE rule356 #-} rule356 = \ ((_lhsIsynMap) :: Map Identifier Attributes) -> _lhsIsynMap {-# INLINE rule357 #-} rule357 = \ _allfields -> _allfields {-# INLINE rule358 #-} rule358 = \ ((_lhsIallnts) :: [Identifier]) -> _lhsIallnts {-# INLINE rule359 #-} rule359 = \ _altAttrs -> _altAttrs {-# INLINE rule360 #-} rule360 = \ _attrs -> _attrs {-# INLINE rule361 #-} rule361 = \ ((_lhsIinh) :: Attributes) -> _lhsIinh {-# INLINE rule362 #-} rule362 = \ _mergeMap -> _mergeMap {-# INLINE rule363 #-} rule363 = \ ((_lhsInt) :: Identifier) -> _lhsInt {-# INLINE rule364 #-} rule364 = \ ((_lhsIo_case) :: Bool) -> _lhsIo_case {-# INLINE rule365 #-} rule365 = \ ((_lhsIo_cata) :: Bool) -> _lhsIo_cata {-# INLINE rule366 #-} rule366 = \ ((_lhsIo_dovisit) :: Bool) -> _lhsIo_dovisit {-# INLINE rule367 #-} rule367 = \ ((_lhsIo_newtypes) :: Bool) -> _lhsIo_newtypes {-# INLINE rule368 #-} rule368 = \ ((_lhsIo_rename) :: Bool) -> _lhsIo_rename {-# INLINE rule369 #-} rule369 = \ ((_lhsIo_sem) :: Bool) -> _lhsIo_sem {-# INLINE rule370 #-} rule370 = \ ((_lhsIo_sig) :: Bool) -> _lhsIo_sig {-# INLINE rule371 #-} rule371 = \ ((_lhsIo_wantvisit) :: Bool) -> _lhsIo_wantvisit {-# INLINE rule372 #-} rule372 = \ ((_lhsIprefix) :: String) -> _lhsIprefix {-# INLINE rule373 #-} rule373 = \ ((_lhsIsyn) :: Attributes) -> _lhsIsyn -- Productions ------------------------------------------------- -- wrapper data Inh_Productions = Inh_Productions { allnts_Inh_Productions :: ([Identifier]), aroundMap_Inh_Productions :: (Map ConstructorIdent (Map Identifier [Expression])), cVisitsMap_Inh_Productions :: (CVisitsMap), inh_Inh_Productions :: (Attributes), inhMap_Inh_Productions :: (Map Identifier Attributes), manualAttrDepMap_Inh_Productions :: (AttrOrderMap), mergeMap_Inh_Productions :: (Map ConstructorIdent (Map Identifier (Identifier,[Identifier]))), nt_Inh_Productions :: (Identifier), o_case_Inh_Productions :: (Bool), o_cata_Inh_Productions :: (Bool), o_dovisit_Inh_Productions :: (Bool), o_newtypes_Inh_Productions :: (Bool), o_rename_Inh_Productions :: (Bool), o_sem_Inh_Productions :: (Bool), o_sig_Inh_Productions :: (Bool), o_unbox_Inh_Productions :: (Bool), o_wantvisit_Inh_Productions :: (Bool), prefix_Inh_Productions :: (String), syn_Inh_Productions :: (Attributes), synMap_Inh_Productions :: (Map Identifier Attributes), vcount_Inh_Productions :: (Int) } data Syn_Productions = Syn_Productions { additionalDep_Syn_Productions :: (Seq Edge), aroundDep_Syn_Productions :: (Seq Edge), cProductions_Syn_Productions :: (CProductions), cons_Syn_Productions :: ([ConstructorIdent]), directDep_Syn_Productions :: (Seq Edge), errors_Syn_Productions :: (Seq Error), instDep_Syn_Productions :: (Seq Edge), mergeDep_Syn_Productions :: (Seq Edge), nAutoRules_Syn_Productions :: (Int), nExplicitRules_Syn_Productions :: (Int), rules_Syn_Productions :: (Seq (Vertex,CRule)), vcount_Syn_Productions :: (Int) } {-# INLINABLE wrap_Productions #-} wrap_Productions :: T_Productions -> Inh_Productions -> (Syn_Productions ) wrap_Productions (T_Productions act) (Inh_Productions _lhsIallnts _lhsIaroundMap _lhsIcVisitsMap _lhsIinh _lhsIinhMap _lhsImanualAttrDepMap _lhsImergeMap _lhsInt _lhsIo_case _lhsIo_cata _lhsIo_dovisit _lhsIo_newtypes _lhsIo_rename _lhsIo_sem _lhsIo_sig _lhsIo_unbox _lhsIo_wantvisit _lhsIprefix _lhsIsyn _lhsIsynMap _lhsIvcount) = Control.Monad.Identity.runIdentity ( do sem <- act let arg = T_Productions_vIn28 _lhsIallnts _lhsIaroundMap _lhsIcVisitsMap _lhsIinh _lhsIinhMap _lhsImanualAttrDepMap _lhsImergeMap _lhsInt _lhsIo_case _lhsIo_cata _lhsIo_dovisit _lhsIo_newtypes _lhsIo_rename _lhsIo_sem _lhsIo_sig _lhsIo_unbox _lhsIo_wantvisit _lhsIprefix _lhsIsyn _lhsIsynMap _lhsIvcount (T_Productions_vOut28 _lhsOadditionalDep _lhsOaroundDep _lhsOcProductions _lhsOcons _lhsOdirectDep _lhsOerrors _lhsOinstDep _lhsOmergeDep _lhsOnAutoRules _lhsOnExplicitRules _lhsOrules _lhsOvcount) <- return (inv_Productions_s29 sem arg) return (Syn_Productions _lhsOadditionalDep _lhsOaroundDep _lhsOcProductions _lhsOcons _lhsOdirectDep _lhsOerrors _lhsOinstDep _lhsOmergeDep _lhsOnAutoRules _lhsOnExplicitRules _lhsOrules _lhsOvcount) ) -- cata {-# NOINLINE sem_Productions #-} sem_Productions :: Productions -> T_Productions sem_Productions list = Prelude.foldr sem_Productions_Cons sem_Productions_Nil (Prelude.map sem_Production list) -- semantic domain newtype T_Productions = T_Productions { attach_T_Productions :: Identity (T_Productions_s29 ) } newtype T_Productions_s29 = C_Productions_s29 { inv_Productions_s29 :: (T_Productions_v28 ) } data T_Productions_s30 = C_Productions_s30 type T_Productions_v28 = (T_Productions_vIn28 ) -> (T_Productions_vOut28 ) data T_Productions_vIn28 = T_Productions_vIn28 ([Identifier]) (Map ConstructorIdent (Map Identifier [Expression])) (CVisitsMap) (Attributes) (Map Identifier Attributes) (AttrOrderMap) (Map ConstructorIdent (Map Identifier (Identifier,[Identifier]))) (Identifier) (Bool) (Bool) (Bool) (Bool) (Bool) (Bool) (Bool) (Bool) (Bool) (String) (Attributes) (Map Identifier Attributes) (Int) data T_Productions_vOut28 = T_Productions_vOut28 (Seq Edge) (Seq Edge) (CProductions) ([ConstructorIdent]) (Seq Edge) (Seq Error) (Seq Edge) (Seq Edge) (Int) (Int) (Seq (Vertex,CRule)) (Int) {-# NOINLINE sem_Productions_Cons #-} sem_Productions_Cons :: T_Production -> T_Productions -> T_Productions sem_Productions_Cons arg_hd_ arg_tl_ = T_Productions (return st29) where {-# NOINLINE st29 #-} st29 = let v28 :: T_Productions_v28 v28 = \ (T_Productions_vIn28 _lhsIallnts _lhsIaroundMap _lhsIcVisitsMap _lhsIinh _lhsIinhMap _lhsImanualAttrDepMap _lhsImergeMap _lhsInt _lhsIo_case _lhsIo_cata _lhsIo_dovisit _lhsIo_newtypes _lhsIo_rename _lhsIo_sem _lhsIo_sig _lhsIo_unbox _lhsIo_wantvisit _lhsIprefix _lhsIsyn _lhsIsynMap _lhsIvcount) -> ( let _hdX26 = Control.Monad.Identity.runIdentity (attach_T_Production (arg_hd_)) _tlX29 = Control.Monad.Identity.runIdentity (attach_T_Productions (arg_tl_)) (T_Production_vOut25 _hdIadditionalDep _hdIaroundDep _hdIcProduction _hdIcons _hdIdirectDep _hdIerrors _hdIinstDep _hdImergeDep _hdInAutoRules _hdInExplicitRules _hdIrules _hdIvcount) = inv_Production_s26 _hdX26 (T_Production_vIn25 _hdOallnts _hdOaroundMap _hdOcVisitsMap _hdOinh _hdOinhMap _hdOmanualAttrDepMap _hdOmergeMap _hdOnt _hdOo_case _hdOo_cata _hdOo_dovisit _hdOo_newtypes _hdOo_rename _hdOo_sem _hdOo_sig _hdOo_unbox _hdOo_wantvisit _hdOprefix _hdOsyn _hdOsynMap _hdOvcount) (T_Productions_vOut28 _tlIadditionalDep _tlIaroundDep _tlIcProductions _tlIcons _tlIdirectDep _tlIerrors _tlIinstDep _tlImergeDep _tlInAutoRules _tlInExplicitRules _tlIrules _tlIvcount) = inv_Productions_s29 _tlX29 (T_Productions_vIn28 _tlOallnts _tlOaroundMap _tlOcVisitsMap _tlOinh _tlOinhMap _tlOmanualAttrDepMap _tlOmergeMap _tlOnt _tlOo_case _tlOo_cata _tlOo_dovisit _tlOo_newtypes _tlOo_rename _tlOo_sem _tlOo_sig _tlOo_unbox _tlOo_wantvisit _tlOprefix _tlOsyn _tlOsynMap _tlOvcount) _lhsOcProductions :: CProductions _lhsOcProductions = rule374 _hdIcProduction _tlIcProductions _lhsOadditionalDep :: Seq Edge _lhsOadditionalDep = rule375 _hdIadditionalDep _tlIadditionalDep _lhsOaroundDep :: Seq Edge _lhsOaroundDep = rule376 _hdIaroundDep _tlIaroundDep _lhsOcons :: [ConstructorIdent] _lhsOcons = rule377 _hdIcons _tlIcons _lhsOdirectDep :: Seq Edge _lhsOdirectDep = rule378 _hdIdirectDep _tlIdirectDep _lhsOerrors :: Seq Error _lhsOerrors = rule379 _hdIerrors _tlIerrors _lhsOinstDep :: Seq Edge _lhsOinstDep = rule380 _hdIinstDep _tlIinstDep _lhsOmergeDep :: Seq Edge _lhsOmergeDep = rule381 _hdImergeDep _tlImergeDep _lhsOnAutoRules :: Int _lhsOnAutoRules = rule382 _hdInAutoRules _tlInAutoRules _lhsOnExplicitRules :: Int _lhsOnExplicitRules = rule383 _hdInExplicitRules _tlInExplicitRules _lhsOrules :: Seq (Vertex,CRule) _lhsOrules = rule384 _hdIrules _tlIrules _lhsOvcount :: Int _lhsOvcount = rule385 _tlIvcount _hdOallnts = rule386 _lhsIallnts _hdOaroundMap = rule387 _lhsIaroundMap _hdOcVisitsMap = rule388 _lhsIcVisitsMap _hdOinh = rule389 _lhsIinh _hdOinhMap = rule390 _lhsIinhMap _hdOmanualAttrDepMap = rule391 _lhsImanualAttrDepMap _hdOmergeMap = rule392 _lhsImergeMap _hdOnt = rule393 _lhsInt _hdOo_case = rule394 _lhsIo_case _hdOo_cata = rule395 _lhsIo_cata _hdOo_dovisit = rule396 _lhsIo_dovisit _hdOo_newtypes = rule397 _lhsIo_newtypes _hdOo_rename = rule398 _lhsIo_rename _hdOo_sem = rule399 _lhsIo_sem _hdOo_sig = rule400 _lhsIo_sig _hdOo_unbox = rule401 _lhsIo_unbox _hdOo_wantvisit = rule402 _lhsIo_wantvisit _hdOprefix = rule403 _lhsIprefix _hdOsyn = rule404 _lhsIsyn _hdOsynMap = rule405 _lhsIsynMap _hdOvcount = rule406 _lhsIvcount _tlOallnts = rule407 _lhsIallnts _tlOaroundMap = rule408 _lhsIaroundMap _tlOcVisitsMap = rule409 _lhsIcVisitsMap _tlOinh = rule410 _lhsIinh _tlOinhMap = rule411 _lhsIinhMap _tlOmanualAttrDepMap = rule412 _lhsImanualAttrDepMap _tlOmergeMap = rule413 _lhsImergeMap _tlOnt = rule414 _lhsInt _tlOo_case = rule415 _lhsIo_case _tlOo_cata = rule416 _lhsIo_cata _tlOo_dovisit = rule417 _lhsIo_dovisit _tlOo_newtypes = rule418 _lhsIo_newtypes _tlOo_rename = rule419 _lhsIo_rename _tlOo_sem = rule420 _lhsIo_sem _tlOo_sig = rule421 _lhsIo_sig _tlOo_unbox = rule422 _lhsIo_unbox _tlOo_wantvisit = rule423 _lhsIo_wantvisit _tlOprefix = rule424 _lhsIprefix _tlOsyn = rule425 _lhsIsyn _tlOsynMap = rule426 _lhsIsynMap _tlOvcount = rule427 _hdIvcount __result_ = T_Productions_vOut28 _lhsOadditionalDep _lhsOaroundDep _lhsOcProductions _lhsOcons _lhsOdirectDep _lhsOerrors _lhsOinstDep _lhsOmergeDep _lhsOnAutoRules _lhsOnExplicitRules _lhsOrules _lhsOvcount in __result_ ) in C_Productions_s29 v28 {-# INLINE rule374 #-} {-# LINE 627 "./src-ag/Order.ag" #-} rule374 = \ ((_hdIcProduction) :: CProduction) ((_tlIcProductions) :: CProductions) -> {-# LINE 627 "./src-ag/Order.ag" #-} _hdIcProduction : _tlIcProductions {-# LINE 2907 "dist/build/Order.hs"#-} {-# INLINE rule375 #-} rule375 = \ ((_hdIadditionalDep) :: Seq Edge) ((_tlIadditionalDep) :: Seq Edge) -> _hdIadditionalDep Seq.>< _tlIadditionalDep {-# INLINE rule376 #-} rule376 = \ ((_hdIaroundDep) :: Seq Edge) ((_tlIaroundDep) :: Seq Edge) -> _hdIaroundDep Seq.>< _tlIaroundDep {-# INLINE rule377 #-} rule377 = \ ((_hdIcons) :: [ConstructorIdent]) ((_tlIcons) :: [ConstructorIdent]) -> _hdIcons ++ _tlIcons {-# INLINE rule378 #-} rule378 = \ ((_hdIdirectDep) :: Seq Edge) ((_tlIdirectDep) :: Seq Edge) -> _hdIdirectDep Seq.>< _tlIdirectDep {-# INLINE rule379 #-} rule379 = \ ((_hdIerrors) :: Seq Error) ((_tlIerrors) :: Seq Error) -> _hdIerrors Seq.>< _tlIerrors {-# INLINE rule380 #-} rule380 = \ ((_hdIinstDep) :: Seq Edge) ((_tlIinstDep) :: Seq Edge) -> _hdIinstDep Seq.>< _tlIinstDep {-# INLINE rule381 #-} rule381 = \ ((_hdImergeDep) :: Seq Edge) ((_tlImergeDep) :: Seq Edge) -> _hdImergeDep Seq.>< _tlImergeDep {-# INLINE rule382 #-} rule382 = \ ((_hdInAutoRules) :: Int) ((_tlInAutoRules) :: Int) -> _hdInAutoRules + _tlInAutoRules {-# INLINE rule383 #-} rule383 = \ ((_hdInExplicitRules) :: Int) ((_tlInExplicitRules) :: Int) -> _hdInExplicitRules + _tlInExplicitRules {-# INLINE rule384 #-} rule384 = \ ((_hdIrules) :: Seq (Vertex,CRule)) ((_tlIrules) :: Seq (Vertex,CRule)) -> _hdIrules Seq.>< _tlIrules {-# INLINE rule385 #-} rule385 = \ ((_tlIvcount) :: Int) -> _tlIvcount {-# INLINE rule386 #-} rule386 = \ ((_lhsIallnts) :: [Identifier]) -> _lhsIallnts {-# INLINE rule387 #-} rule387 = \ ((_lhsIaroundMap) :: Map ConstructorIdent (Map Identifier [Expression])) -> _lhsIaroundMap {-# INLINE rule388 #-} rule388 = \ ((_lhsIcVisitsMap) :: CVisitsMap) -> _lhsIcVisitsMap {-# INLINE rule389 #-} rule389 = \ ((_lhsIinh) :: Attributes) -> _lhsIinh {-# INLINE rule390 #-} rule390 = \ ((_lhsIinhMap) :: Map Identifier Attributes) -> _lhsIinhMap {-# INLINE rule391 #-} rule391 = \ ((_lhsImanualAttrDepMap) :: AttrOrderMap) -> _lhsImanualAttrDepMap {-# INLINE rule392 #-} rule392 = \ ((_lhsImergeMap) :: Map ConstructorIdent (Map Identifier (Identifier,[Identifier]))) -> _lhsImergeMap {-# INLINE rule393 #-} rule393 = \ ((_lhsInt) :: Identifier) -> _lhsInt {-# INLINE rule394 #-} rule394 = \ ((_lhsIo_case) :: Bool) -> _lhsIo_case {-# INLINE rule395 #-} rule395 = \ ((_lhsIo_cata) :: Bool) -> _lhsIo_cata {-# INLINE rule396 #-} rule396 = \ ((_lhsIo_dovisit) :: Bool) -> _lhsIo_dovisit {-# INLINE rule397 #-} rule397 = \ ((_lhsIo_newtypes) :: Bool) -> _lhsIo_newtypes {-# INLINE rule398 #-} rule398 = \ ((_lhsIo_rename) :: Bool) -> _lhsIo_rename {-# INLINE rule399 #-} rule399 = \ ((_lhsIo_sem) :: Bool) -> _lhsIo_sem {-# INLINE rule400 #-} rule400 = \ ((_lhsIo_sig) :: Bool) -> _lhsIo_sig {-# INLINE rule401 #-} rule401 = \ ((_lhsIo_unbox) :: Bool) -> _lhsIo_unbox {-# INLINE rule402 #-} rule402 = \ ((_lhsIo_wantvisit) :: Bool) -> _lhsIo_wantvisit {-# INLINE rule403 #-} rule403 = \ ((_lhsIprefix) :: String) -> _lhsIprefix {-# INLINE rule404 #-} rule404 = \ ((_lhsIsyn) :: Attributes) -> _lhsIsyn {-# INLINE rule405 #-} rule405 = \ ((_lhsIsynMap) :: Map Identifier Attributes) -> _lhsIsynMap {-# INLINE rule406 #-} rule406 = \ ((_lhsIvcount) :: Int) -> _lhsIvcount {-# INLINE rule407 #-} rule407 = \ ((_lhsIallnts) :: [Identifier]) -> _lhsIallnts {-# INLINE rule408 #-} rule408 = \ ((_lhsIaroundMap) :: Map ConstructorIdent (Map Identifier [Expression])) -> _lhsIaroundMap {-# INLINE rule409 #-} rule409 = \ ((_lhsIcVisitsMap) :: CVisitsMap) -> _lhsIcVisitsMap {-# INLINE rule410 #-} rule410 = \ ((_lhsIinh) :: Attributes) -> _lhsIinh {-# INLINE rule411 #-} rule411 = \ ((_lhsIinhMap) :: Map Identifier Attributes) -> _lhsIinhMap {-# INLINE rule412 #-} rule412 = \ ((_lhsImanualAttrDepMap) :: AttrOrderMap) -> _lhsImanualAttrDepMap {-# INLINE rule413 #-} rule413 = \ ((_lhsImergeMap) :: Map ConstructorIdent (Map Identifier (Identifier,[Identifier]))) -> _lhsImergeMap {-# INLINE rule414 #-} rule414 = \ ((_lhsInt) :: Identifier) -> _lhsInt {-# INLINE rule415 #-} rule415 = \ ((_lhsIo_case) :: Bool) -> _lhsIo_case {-# INLINE rule416 #-} rule416 = \ ((_lhsIo_cata) :: Bool) -> _lhsIo_cata {-# INLINE rule417 #-} rule417 = \ ((_lhsIo_dovisit) :: Bool) -> _lhsIo_dovisit {-# INLINE rule418 #-} rule418 = \ ((_lhsIo_newtypes) :: Bool) -> _lhsIo_newtypes {-# INLINE rule419 #-} rule419 = \ ((_lhsIo_rename) :: Bool) -> _lhsIo_rename {-# INLINE rule420 #-} rule420 = \ ((_lhsIo_sem) :: Bool) -> _lhsIo_sem {-# INLINE rule421 #-} rule421 = \ ((_lhsIo_sig) :: Bool) -> _lhsIo_sig {-# INLINE rule422 #-} rule422 = \ ((_lhsIo_unbox) :: Bool) -> _lhsIo_unbox {-# INLINE rule423 #-} rule423 = \ ((_lhsIo_wantvisit) :: Bool) -> _lhsIo_wantvisit {-# INLINE rule424 #-} rule424 = \ ((_lhsIprefix) :: String) -> _lhsIprefix {-# INLINE rule425 #-} rule425 = \ ((_lhsIsyn) :: Attributes) -> _lhsIsyn {-# INLINE rule426 #-} rule426 = \ ((_lhsIsynMap) :: Map Identifier Attributes) -> _lhsIsynMap {-# INLINE rule427 #-} rule427 = \ ((_hdIvcount) :: Int) -> _hdIvcount {-# NOINLINE sem_Productions_Nil #-} sem_Productions_Nil :: T_Productions sem_Productions_Nil = T_Productions (return st29) where {-# NOINLINE st29 #-} st29 = let v28 :: T_Productions_v28 v28 = \ (T_Productions_vIn28 _lhsIallnts _lhsIaroundMap _lhsIcVisitsMap _lhsIinh _lhsIinhMap _lhsImanualAttrDepMap _lhsImergeMap _lhsInt _lhsIo_case _lhsIo_cata _lhsIo_dovisit _lhsIo_newtypes _lhsIo_rename _lhsIo_sem _lhsIo_sig _lhsIo_unbox _lhsIo_wantvisit _lhsIprefix _lhsIsyn _lhsIsynMap _lhsIvcount) -> ( let _lhsOcProductions :: CProductions _lhsOcProductions = rule428 () _lhsOadditionalDep :: Seq Edge _lhsOadditionalDep = rule429 () _lhsOaroundDep :: Seq Edge _lhsOaroundDep = rule430 () _lhsOcons :: [ConstructorIdent] _lhsOcons = rule431 () _lhsOdirectDep :: Seq Edge _lhsOdirectDep = rule432 () _lhsOerrors :: Seq Error _lhsOerrors = rule433 () _lhsOinstDep :: Seq Edge _lhsOinstDep = rule434 () _lhsOmergeDep :: Seq Edge _lhsOmergeDep = rule435 () _lhsOnAutoRules :: Int _lhsOnAutoRules = rule436 () _lhsOnExplicitRules :: Int _lhsOnExplicitRules = rule437 () _lhsOrules :: Seq (Vertex,CRule) _lhsOrules = rule438 () _lhsOvcount :: Int _lhsOvcount = rule439 _lhsIvcount __result_ = T_Productions_vOut28 _lhsOadditionalDep _lhsOaroundDep _lhsOcProductions _lhsOcons _lhsOdirectDep _lhsOerrors _lhsOinstDep _lhsOmergeDep _lhsOnAutoRules _lhsOnExplicitRules _lhsOrules _lhsOvcount in __result_ ) in C_Productions_s29 v28 {-# INLINE rule428 #-} {-# LINE 628 "./src-ag/Order.ag" #-} rule428 = \ (_ :: ()) -> {-# LINE 628 "./src-ag/Order.ag" #-} [] {-# LINE 3106 "dist/build/Order.hs"#-} {-# INLINE rule429 #-} rule429 = \ (_ :: ()) -> Seq.empty {-# INLINE rule430 #-} rule430 = \ (_ :: ()) -> Seq.empty {-# INLINE rule431 #-} rule431 = \ (_ :: ()) -> [] {-# INLINE rule432 #-} rule432 = \ (_ :: ()) -> Seq.empty {-# INLINE rule433 #-} rule433 = \ (_ :: ()) -> Seq.empty {-# INLINE rule434 #-} rule434 = \ (_ :: ()) -> Seq.empty {-# INLINE rule435 #-} rule435 = \ (_ :: ()) -> Seq.empty {-# INLINE rule436 #-} rule436 = \ (_ :: ()) -> 0 {-# INLINE rule437 #-} rule437 = \ (_ :: ()) -> 0 {-# INLINE rule438 #-} rule438 = \ (_ :: ()) -> Seq.empty {-# INLINE rule439 #-} rule439 = \ ((_lhsIvcount) :: Int) -> _lhsIvcount -- Rule -------------------------------------------------------- -- wrapper data Inh_Rule = Inh_Rule { allTypeSigs_Inh_Rule :: (Map Identifier Type), allfields_Inh_Rule :: ([(Identifier,Type,ChildKind)]), allnts_Inh_Rule :: ([Identifier]), altAttrs_Inh_Rule :: (Map AltAttr Vertex), attrs_Inh_Rule :: ([(Identifier,Identifier)]), childInhs_Inh_Rule :: (Map Identifier Attributes), childNts_Inh_Rule :: (Map Identifier NontermIdent), con_Inh_Rule :: (Identifier), inh_Inh_Rule :: (Attributes), inhsOfChildren_Inh_Rule :: (Map Identifier Attributes), mergeMap_Inh_Rule :: (Map Identifier (Identifier,[Identifier])), nt_Inh_Rule :: (Identifier), o_case_Inh_Rule :: (Bool), o_cata_Inh_Rule :: (Bool), o_dovisit_Inh_Rule :: (Bool), o_newtypes_Inh_Rule :: (Bool), o_rename_Inh_Rule :: (Bool), o_sem_Inh_Rule :: (Bool), o_sig_Inh_Rule :: (Bool), o_wantvisit_Inh_Rule :: (Bool), prefix_Inh_Rule :: (String), syn_Inh_Rule :: (Attributes), synsOfChildren_Inh_Rule :: (Map Identifier Attributes) } data Syn_Rule = Syn_Rule { directDep_Syn_Rule :: (Seq Edge), errors_Syn_Rule :: (Seq Error), gathAltAttrs_Syn_Rule :: ([AltAttr]), gathRules_Syn_Rule :: (Seq CRule), instDep_Syn_Rule :: (Seq Edge), instVars_Syn_Rule :: ([Identifier]), locVars_Syn_Rule :: ([Identifier]), nAutoRules_Syn_Rule :: (Int), nExplicitRules_Syn_Rule :: (Int) } {-# INLINABLE wrap_Rule #-} wrap_Rule :: T_Rule -> Inh_Rule -> (Syn_Rule ) wrap_Rule (T_Rule act) (Inh_Rule _lhsIallTypeSigs _lhsIallfields _lhsIallnts _lhsIaltAttrs _lhsIattrs _lhsIchildInhs _lhsIchildNts _lhsIcon _lhsIinh _lhsIinhsOfChildren _lhsImergeMap _lhsInt _lhsIo_case _lhsIo_cata _lhsIo_dovisit _lhsIo_newtypes _lhsIo_rename _lhsIo_sem _lhsIo_sig _lhsIo_wantvisit _lhsIprefix _lhsIsyn _lhsIsynsOfChildren) = Control.Monad.Identity.runIdentity ( do sem <- act let arg = T_Rule_vIn31 _lhsIallTypeSigs _lhsIallfields _lhsIallnts _lhsIaltAttrs _lhsIattrs _lhsIchildInhs _lhsIchildNts _lhsIcon _lhsIinh _lhsIinhsOfChildren _lhsImergeMap _lhsInt _lhsIo_case _lhsIo_cata _lhsIo_dovisit _lhsIo_newtypes _lhsIo_rename _lhsIo_sem _lhsIo_sig _lhsIo_wantvisit _lhsIprefix _lhsIsyn _lhsIsynsOfChildren (T_Rule_vOut31 _lhsOdirectDep _lhsOerrors _lhsOgathAltAttrs _lhsOgathRules _lhsOinstDep _lhsOinstVars _lhsOlocVars _lhsOnAutoRules _lhsOnExplicitRules) <- return (inv_Rule_s32 sem arg) return (Syn_Rule _lhsOdirectDep _lhsOerrors _lhsOgathAltAttrs _lhsOgathRules _lhsOinstDep _lhsOinstVars _lhsOlocVars _lhsOnAutoRules _lhsOnExplicitRules) ) -- cata {-# INLINE sem_Rule #-} sem_Rule :: Rule -> T_Rule sem_Rule ( Rule mbName_ pattern_ rhs_ owrt_ origin_ explicit_ pure_ identity_ mbError_ eager_ ) = sem_Rule_Rule mbName_ ( sem_Pattern pattern_ ) ( sem_Expression rhs_ ) owrt_ origin_ explicit_ pure_ identity_ mbError_ eager_ -- semantic domain newtype T_Rule = T_Rule { attach_T_Rule :: Identity (T_Rule_s32 ) } newtype T_Rule_s32 = C_Rule_s32 { inv_Rule_s32 :: (T_Rule_v31 ) } data T_Rule_s33 = C_Rule_s33 type T_Rule_v31 = (T_Rule_vIn31 ) -> (T_Rule_vOut31 ) data T_Rule_vIn31 = T_Rule_vIn31 (Map Identifier Type) ([(Identifier,Type,ChildKind)]) ([Identifier]) (Map AltAttr Vertex) ([(Identifier,Identifier)]) (Map Identifier Attributes) (Map Identifier NontermIdent) (Identifier) (Attributes) (Map Identifier Attributes) (Map Identifier (Identifier,[Identifier])) (Identifier) (Bool) (Bool) (Bool) (Bool) (Bool) (Bool) (Bool) (Bool) (String) (Attributes) (Map Identifier Attributes) data T_Rule_vOut31 = T_Rule_vOut31 (Seq Edge) (Seq Error) ([AltAttr]) (Seq CRule) (Seq Edge) ([Identifier]) ([Identifier]) (Int) (Int) {-# NOINLINE sem_Rule_Rule #-} sem_Rule_Rule :: (Maybe Identifier) -> T_Pattern -> T_Expression -> (Bool) -> (String) -> (Bool) -> (Bool) -> (Bool) -> (Maybe Error) -> (Bool) -> T_Rule sem_Rule_Rule arg_mbName_ arg_pattern_ arg_rhs_ arg_owrt_ arg_origin_ arg_explicit_ _ _ _ _ = T_Rule (return st32) where {-# NOINLINE st32 #-} st32 = let v31 :: T_Rule_v31 v31 = \ (T_Rule_vIn31 _lhsIallTypeSigs _lhsIallfields _lhsIallnts _lhsIaltAttrs _lhsIattrs _lhsIchildInhs _lhsIchildNts _lhsIcon _lhsIinh _lhsIinhsOfChildren _lhsImergeMap _lhsInt _lhsIo_case _lhsIo_cata _lhsIo_dovisit _lhsIo_newtypes _lhsIo_rename _lhsIo_sem _lhsIo_sig _lhsIo_wantvisit _lhsIprefix _lhsIsyn _lhsIsynsOfChildren) -> ( let _patternX20 = Control.Monad.Identity.runIdentity (attach_T_Pattern (arg_pattern_)) _rhsX8 = Control.Monad.Identity.runIdentity (attach_T_Expression (arg_rhs_)) (T_Pattern_vOut19 _patternIcopy _patternIerrors _patternIgathAltAttrs _patternIinstVars _patternIlocVars _patternIpatternAttrs) = inv_Pattern_s20 _patternX20 (T_Pattern_vIn19 _patternOallTypeSigs _patternOaltAttrs _patternOcon _patternOinh _patternOnt _patternOsyn) (T_Expression_vOut7 _rhsIallRhsVars _rhsIcopy _rhsIerrors _rhsItextLines _rhsIusedAttrs _rhsIusedFields _rhsIusedLocals) = inv_Expression_s8 _rhsX8 (T_Expression_vIn7 _rhsOallfields _rhsOallnts _rhsOattrs _rhsOcon _rhsOmergeMap _rhsOnt) _lhsOnExplicitRules :: Int _lhsOnExplicitRules = rule440 arg_explicit_ _lhsOnAutoRules :: Int _lhsOnAutoRules = rule441 arg_origin_ _defines = rule442 _lhsIallTypeSigs _lhsIaltAttrs _lhsIchildInhs _lhsIsyn _patternIpatternAttrs _gathRules = rule443 _defines _lhsIchildNts _lhsIcon _lhsInt _patternIcopy _rhsIallRhsVars _rhsItextLines arg_explicit_ arg_mbName_ arg_origin_ arg_owrt_ _lhsOdirectDep :: Seq Edge _lhsOdirectDep = rule444 _defines _lhsIaltAttrs _rhsIusedAttrs _rhsIusedFields _rhsIusedLocals _instDep1 = rule445 _defines _lhsIaltAttrs _lhsIsynsOfChildren _instDep2 = rule446 _defines _lhsIaltAttrs _lhsIinhsOfChildren _lhsOinstDep :: Seq Edge _lhsOinstDep = rule447 _instDep1 _instDep2 _lhsOerrors :: Seq Error _lhsOerrors = rule448 _patternIerrors _rhsIerrors _lhsOgathAltAttrs :: [AltAttr] _lhsOgathAltAttrs = rule449 _patternIgathAltAttrs _lhsOgathRules :: Seq CRule _lhsOgathRules = rule450 _gathRules _lhsOinstVars :: [Identifier] _lhsOinstVars = rule451 _patternIinstVars _lhsOlocVars :: [Identifier] _lhsOlocVars = rule452 _patternIlocVars _patternOallTypeSigs = rule453 _lhsIallTypeSigs _patternOaltAttrs = rule454 _lhsIaltAttrs _patternOcon = rule455 _lhsIcon _patternOinh = rule456 _lhsIinh _patternOnt = rule457 _lhsInt _patternOsyn = rule458 _lhsIsyn _rhsOallfields = rule459 _lhsIallfields _rhsOallnts = rule460 _lhsIallnts _rhsOattrs = rule461 _lhsIattrs _rhsOcon = rule462 _lhsIcon _rhsOmergeMap = rule463 _lhsImergeMap _rhsOnt = rule464 _lhsInt __result_ = T_Rule_vOut31 _lhsOdirectDep _lhsOerrors _lhsOgathAltAttrs _lhsOgathRules _lhsOinstDep _lhsOinstVars _lhsOlocVars _lhsOnAutoRules _lhsOnExplicitRules in __result_ ) in C_Rule_s32 v31 {-# INLINE rule440 #-} {-# LINE 65 "./src-ag/Order.ag" #-} rule440 = \ explicit_ -> {-# LINE 65 "./src-ag/Order.ag" #-} if explicit_ then 1 else 0 {-# LINE 3226 "dist/build/Order.hs"#-} {-# INLINE rule441 #-} {-# LINE 68 "./src-ag/Order.ag" #-} rule441 = \ origin_ -> {-# LINE 68 "./src-ag/Order.ag" #-} if startsWith "use rule" origin_ || startsWith "copy rule" origin_ then 1 else 0 {-# LINE 3234 "dist/build/Order.hs"#-} {-# INLINE rule442 #-} {-# LINE 218 "./src-ag/Order.ag" #-} rule442 = \ ((_lhsIallTypeSigs) :: Map Identifier Type) ((_lhsIaltAttrs) :: Map AltAttr Vertex) ((_lhsIchildInhs) :: Map Identifier Attributes) ((_lhsIsyn) :: Attributes) ((_patternIpatternAttrs) :: [(Identifier,Identifier,Bool)]) -> {-# LINE 218 "./src-ag/Order.ag" #-} let tp field attr | field == _LOC || field == _INST = Map.lookup attr _lhsIallTypeSigs | field == _LHS = Map.lookup attr _lhsIsyn | otherwise = Map.lookup attr (findWithErr1 "Rule.defines.tp" field _lhsIchildInhs) typ :: Pattern -> Maybe Type typ (Alias field attr _) = tp field attr typ (Underscore _) = Nothing typ _ = Nothing in Map.fromList [ (findWithErr1 "Rule.defines" aa _lhsIaltAttrs, (field,attr,(tp field attr))) | (field,attr,isLocalOrInst) <- _patternIpatternAttrs , let aa = AltAttr field attr isLocalOrInst ] {-# LINE 3251 "dist/build/Order.hs"#-} {-# INLINE rule443 #-} {-# LINE 232 "./src-ag/Order.ag" #-} rule443 = \ _defines ((_lhsIchildNts) :: Map Identifier NontermIdent) ((_lhsIcon) :: Identifier) ((_lhsInt) :: Identifier) ((_patternIcopy) :: Pattern) ((_rhsIallRhsVars) :: Set (Identifier,Identifier)) ((_rhsItextLines) :: [String]) explicit_ mbName_ origin_ owrt_ -> {-# LINE 232 "./src-ag/Order.ag" #-} let childnt field = Map.lookup field _lhsIchildNts in Seq.fromList [ CRule attr False True _lhsInt _lhsIcon field (childnt field) tp _patternIcopy _rhsItextLines _defines owrt_ origin_ _rhsIallRhsVars explicit_ mbName_ | (field,attr,tp) <- Map.elems _defines ] {-# LINE 3260 "dist/build/Order.hs"#-} {-# INLINE rule444 #-} {-# LINE 271 "./src-ag/Order.ag" #-} rule444 = \ _defines ((_lhsIaltAttrs) :: Map AltAttr Vertex) ((_rhsIusedAttrs) :: [(Identifier,Identifier)]) ((_rhsIusedFields) :: [Identifier]) ((_rhsIusedLocals) :: [Identifier]) -> {-# LINE 271 "./src-ag/Order.ag" #-} let defined = Map.keys _defines used = [ Map.lookup (AltAttr field attr True) _lhsIaltAttrs | (field,attr) <- _rhsIusedAttrs] ++ [ Map.lookup (AltAttr _LOC attr True) _lhsIaltAttrs | attr <- _rhsIusedLocals ++ _rhsIusedFields ] in Seq.fromList [ (x,y) | Just x <- used, y <- defined ] {-# LINE 3269 "dist/build/Order.hs"#-} {-# INLINE rule445 #-} {-# LINE 315 "./src-ag/Order.ag" #-} rule445 = \ _defines ((_lhsIaltAttrs) :: Map AltAttr Vertex) ((_lhsIsynsOfChildren) :: Map Identifier Attributes) -> {-# LINE 315 "./src-ag/Order.ag" #-} Seq.fromList $ [ (instVert, synVert) | (field,instNm,_) <- Map.elems _defines , field == _INST , synNm <- Map.keys (findWithErr2 instNm _lhsIsynsOfChildren) , let instAttr = AltAttr _INST instNm True synAttr = AltAttr instNm synNm True instVert = findWithErr2 instAttr _lhsIaltAttrs synVert = findWithErr2 synAttr _lhsIaltAttrs ] {-# LINE 3284 "dist/build/Order.hs"#-} {-# INLINE rule446 #-} {-# LINE 326 "./src-ag/Order.ag" #-} rule446 = \ _defines ((_lhsIaltAttrs) :: Map AltAttr Vertex) ((_lhsIinhsOfChildren) :: Map Identifier Attributes) -> {-# LINE 326 "./src-ag/Order.ag" #-} Seq.fromList $ [ (instVert, inhVert) | (field,instNm,_) <- Map.elems _defines , field == _INST , inhNm <- Map.keys (findWithErr2 instNm _lhsIinhsOfChildren) , let instAttr = AltAttr _INST instNm True inhAttr = AltAttr instNm inhNm False instVert = findWithErr2 instAttr _lhsIaltAttrs inhVert = findWithErr2 inhAttr _lhsIaltAttrs ] {-# LINE 3299 "dist/build/Order.hs"#-} {-# INLINE rule447 #-} {-# LINE 336 "./src-ag/Order.ag" #-} rule447 = \ _instDep1 _instDep2 -> {-# LINE 336 "./src-ag/Order.ag" #-} _instDep1 Seq.>< _instDep2 {-# LINE 3305 "dist/build/Order.hs"#-} {-# INLINE rule448 #-} rule448 = \ ((_patternIerrors) :: Seq Error) ((_rhsIerrors) :: Seq Error) -> _patternIerrors Seq.>< _rhsIerrors {-# INLINE rule449 #-} rule449 = \ ((_patternIgathAltAttrs) :: [AltAttr]) -> _patternIgathAltAttrs {-# INLINE rule450 #-} rule450 = \ _gathRules -> _gathRules {-# INLINE rule451 #-} rule451 = \ ((_patternIinstVars) :: [Identifier]) -> _patternIinstVars {-# INLINE rule452 #-} rule452 = \ ((_patternIlocVars) :: [Identifier]) -> _patternIlocVars {-# INLINE rule453 #-} rule453 = \ ((_lhsIallTypeSigs) :: Map Identifier Type) -> _lhsIallTypeSigs {-# INLINE rule454 #-} rule454 = \ ((_lhsIaltAttrs) :: Map AltAttr Vertex) -> _lhsIaltAttrs {-# INLINE rule455 #-} rule455 = \ ((_lhsIcon) :: Identifier) -> _lhsIcon {-# INLINE rule456 #-} rule456 = \ ((_lhsIinh) :: Attributes) -> _lhsIinh {-# INLINE rule457 #-} rule457 = \ ((_lhsInt) :: Identifier) -> _lhsInt {-# INLINE rule458 #-} rule458 = \ ((_lhsIsyn) :: Attributes) -> _lhsIsyn {-# INLINE rule459 #-} rule459 = \ ((_lhsIallfields) :: [(Identifier,Type,ChildKind)]) -> _lhsIallfields {-# INLINE rule460 #-} rule460 = \ ((_lhsIallnts) :: [Identifier]) -> _lhsIallnts {-# INLINE rule461 #-} rule461 = \ ((_lhsIattrs) :: [(Identifier,Identifier)]) -> _lhsIattrs {-# INLINE rule462 #-} rule462 = \ ((_lhsIcon) :: Identifier) -> _lhsIcon {-# INLINE rule463 #-} rule463 = \ ((_lhsImergeMap) :: Map Identifier (Identifier,[Identifier])) -> _lhsImergeMap {-# INLINE rule464 #-} rule464 = \ ((_lhsInt) :: Identifier) -> _lhsInt -- Rules ------------------------------------------------------- -- wrapper data Inh_Rules = Inh_Rules { allTypeSigs_Inh_Rules :: (Map Identifier Type), allfields_Inh_Rules :: ([(Identifier,Type,ChildKind)]), allnts_Inh_Rules :: ([Identifier]), altAttrs_Inh_Rules :: (Map AltAttr Vertex), attrs_Inh_Rules :: ([(Identifier,Identifier)]), childInhs_Inh_Rules :: (Map Identifier Attributes), childNts_Inh_Rules :: (Map Identifier NontermIdent), con_Inh_Rules :: (Identifier), inh_Inh_Rules :: (Attributes), inhsOfChildren_Inh_Rules :: (Map Identifier Attributes), mergeMap_Inh_Rules :: (Map Identifier (Identifier,[Identifier])), nt_Inh_Rules :: (Identifier), o_case_Inh_Rules :: (Bool), o_cata_Inh_Rules :: (Bool), o_dovisit_Inh_Rules :: (Bool), o_newtypes_Inh_Rules :: (Bool), o_rename_Inh_Rules :: (Bool), o_sem_Inh_Rules :: (Bool), o_sig_Inh_Rules :: (Bool), o_wantvisit_Inh_Rules :: (Bool), prefix_Inh_Rules :: (String), syn_Inh_Rules :: (Attributes), synsOfChildren_Inh_Rules :: (Map Identifier Attributes) } data Syn_Rules = Syn_Rules { directDep_Syn_Rules :: (Seq Edge), errors_Syn_Rules :: (Seq Error), gathAltAttrs_Syn_Rules :: ([AltAttr]), gathRules_Syn_Rules :: (Seq CRule), instDep_Syn_Rules :: (Seq Edge), instVars_Syn_Rules :: ([Identifier]), locVars_Syn_Rules :: ([Identifier]), nAutoRules_Syn_Rules :: (Int), nExplicitRules_Syn_Rules :: (Int) } {-# INLINABLE wrap_Rules #-} wrap_Rules :: T_Rules -> Inh_Rules -> (Syn_Rules ) wrap_Rules (T_Rules act) (Inh_Rules _lhsIallTypeSigs _lhsIallfields _lhsIallnts _lhsIaltAttrs _lhsIattrs _lhsIchildInhs _lhsIchildNts _lhsIcon _lhsIinh _lhsIinhsOfChildren _lhsImergeMap _lhsInt _lhsIo_case _lhsIo_cata _lhsIo_dovisit _lhsIo_newtypes _lhsIo_rename _lhsIo_sem _lhsIo_sig _lhsIo_wantvisit _lhsIprefix _lhsIsyn _lhsIsynsOfChildren) = Control.Monad.Identity.runIdentity ( do sem <- act let arg = T_Rules_vIn34 _lhsIallTypeSigs _lhsIallfields _lhsIallnts _lhsIaltAttrs _lhsIattrs _lhsIchildInhs _lhsIchildNts _lhsIcon _lhsIinh _lhsIinhsOfChildren _lhsImergeMap _lhsInt _lhsIo_case _lhsIo_cata _lhsIo_dovisit _lhsIo_newtypes _lhsIo_rename _lhsIo_sem _lhsIo_sig _lhsIo_wantvisit _lhsIprefix _lhsIsyn _lhsIsynsOfChildren (T_Rules_vOut34 _lhsOdirectDep _lhsOerrors _lhsOgathAltAttrs _lhsOgathRules _lhsOinstDep _lhsOinstVars _lhsOlocVars _lhsOnAutoRules _lhsOnExplicitRules) <- return (inv_Rules_s35 sem arg) return (Syn_Rules _lhsOdirectDep _lhsOerrors _lhsOgathAltAttrs _lhsOgathRules _lhsOinstDep _lhsOinstVars _lhsOlocVars _lhsOnAutoRules _lhsOnExplicitRules) ) -- cata {-# NOINLINE sem_Rules #-} sem_Rules :: Rules -> T_Rules sem_Rules list = Prelude.foldr sem_Rules_Cons sem_Rules_Nil (Prelude.map sem_Rule list) -- semantic domain newtype T_Rules = T_Rules { attach_T_Rules :: Identity (T_Rules_s35 ) } newtype T_Rules_s35 = C_Rules_s35 { inv_Rules_s35 :: (T_Rules_v34 ) } data T_Rules_s36 = C_Rules_s36 type T_Rules_v34 = (T_Rules_vIn34 ) -> (T_Rules_vOut34 ) data T_Rules_vIn34 = T_Rules_vIn34 (Map Identifier Type) ([(Identifier,Type,ChildKind)]) ([Identifier]) (Map AltAttr Vertex) ([(Identifier,Identifier)]) (Map Identifier Attributes) (Map Identifier NontermIdent) (Identifier) (Attributes) (Map Identifier Attributes) (Map Identifier (Identifier,[Identifier])) (Identifier) (Bool) (Bool) (Bool) (Bool) (Bool) (Bool) (Bool) (Bool) (String) (Attributes) (Map Identifier Attributes) data T_Rules_vOut34 = T_Rules_vOut34 (Seq Edge) (Seq Error) ([AltAttr]) (Seq CRule) (Seq Edge) ([Identifier]) ([Identifier]) (Int) (Int) {-# NOINLINE sem_Rules_Cons #-} sem_Rules_Cons :: T_Rule -> T_Rules -> T_Rules sem_Rules_Cons arg_hd_ arg_tl_ = T_Rules (return st35) where {-# NOINLINE st35 #-} st35 = let v34 :: T_Rules_v34 v34 = \ (T_Rules_vIn34 _lhsIallTypeSigs _lhsIallfields _lhsIallnts _lhsIaltAttrs _lhsIattrs _lhsIchildInhs _lhsIchildNts _lhsIcon _lhsIinh _lhsIinhsOfChildren _lhsImergeMap _lhsInt _lhsIo_case _lhsIo_cata _lhsIo_dovisit _lhsIo_newtypes _lhsIo_rename _lhsIo_sem _lhsIo_sig _lhsIo_wantvisit _lhsIprefix _lhsIsyn _lhsIsynsOfChildren) -> ( let _hdX32 = Control.Monad.Identity.runIdentity (attach_T_Rule (arg_hd_)) _tlX35 = Control.Monad.Identity.runIdentity (attach_T_Rules (arg_tl_)) (T_Rule_vOut31 _hdIdirectDep _hdIerrors _hdIgathAltAttrs _hdIgathRules _hdIinstDep _hdIinstVars _hdIlocVars _hdInAutoRules _hdInExplicitRules) = inv_Rule_s32 _hdX32 (T_Rule_vIn31 _hdOallTypeSigs _hdOallfields _hdOallnts _hdOaltAttrs _hdOattrs _hdOchildInhs _hdOchildNts _hdOcon _hdOinh _hdOinhsOfChildren _hdOmergeMap _hdOnt _hdOo_case _hdOo_cata _hdOo_dovisit _hdOo_newtypes _hdOo_rename _hdOo_sem _hdOo_sig _hdOo_wantvisit _hdOprefix _hdOsyn _hdOsynsOfChildren) (T_Rules_vOut34 _tlIdirectDep _tlIerrors _tlIgathAltAttrs _tlIgathRules _tlIinstDep _tlIinstVars _tlIlocVars _tlInAutoRules _tlInExplicitRules) = inv_Rules_s35 _tlX35 (T_Rules_vIn34 _tlOallTypeSigs _tlOallfields _tlOallnts _tlOaltAttrs _tlOattrs _tlOchildInhs _tlOchildNts _tlOcon _tlOinh _tlOinhsOfChildren _tlOmergeMap _tlOnt _tlOo_case _tlOo_cata _tlOo_dovisit _tlOo_newtypes _tlOo_rename _tlOo_sem _tlOo_sig _tlOo_wantvisit _tlOprefix _tlOsyn _tlOsynsOfChildren) _lhsOdirectDep :: Seq Edge _lhsOdirectDep = rule465 _hdIdirectDep _tlIdirectDep _lhsOerrors :: Seq Error _lhsOerrors = rule466 _hdIerrors _tlIerrors _lhsOgathAltAttrs :: [AltAttr] _lhsOgathAltAttrs = rule467 _hdIgathAltAttrs _tlIgathAltAttrs _lhsOgathRules :: Seq CRule _lhsOgathRules = rule468 _hdIgathRules _tlIgathRules _lhsOinstDep :: Seq Edge _lhsOinstDep = rule469 _hdIinstDep _tlIinstDep _lhsOinstVars :: [Identifier] _lhsOinstVars = rule470 _hdIinstVars _tlIinstVars _lhsOlocVars :: [Identifier] _lhsOlocVars = rule471 _hdIlocVars _tlIlocVars _lhsOnAutoRules :: Int _lhsOnAutoRules = rule472 _hdInAutoRules _tlInAutoRules _lhsOnExplicitRules :: Int _lhsOnExplicitRules = rule473 _hdInExplicitRules _tlInExplicitRules _hdOallTypeSigs = rule474 _lhsIallTypeSigs _hdOallfields = rule475 _lhsIallfields _hdOallnts = rule476 _lhsIallnts _hdOaltAttrs = rule477 _lhsIaltAttrs _hdOattrs = rule478 _lhsIattrs _hdOchildInhs = rule479 _lhsIchildInhs _hdOchildNts = rule480 _lhsIchildNts _hdOcon = rule481 _lhsIcon _hdOinh = rule482 _lhsIinh _hdOinhsOfChildren = rule483 _lhsIinhsOfChildren _hdOmergeMap = rule484 _lhsImergeMap _hdOnt = rule485 _lhsInt _hdOo_case = rule486 _lhsIo_case _hdOo_cata = rule487 _lhsIo_cata _hdOo_dovisit = rule488 _lhsIo_dovisit _hdOo_newtypes = rule489 _lhsIo_newtypes _hdOo_rename = rule490 _lhsIo_rename _hdOo_sem = rule491 _lhsIo_sem _hdOo_sig = rule492 _lhsIo_sig _hdOo_wantvisit = rule493 _lhsIo_wantvisit _hdOprefix = rule494 _lhsIprefix _hdOsyn = rule495 _lhsIsyn _hdOsynsOfChildren = rule496 _lhsIsynsOfChildren _tlOallTypeSigs = rule497 _lhsIallTypeSigs _tlOallfields = rule498 _lhsIallfields _tlOallnts = rule499 _lhsIallnts _tlOaltAttrs = rule500 _lhsIaltAttrs _tlOattrs = rule501 _lhsIattrs _tlOchildInhs = rule502 _lhsIchildInhs _tlOchildNts = rule503 _lhsIchildNts _tlOcon = rule504 _lhsIcon _tlOinh = rule505 _lhsIinh _tlOinhsOfChildren = rule506 _lhsIinhsOfChildren _tlOmergeMap = rule507 _lhsImergeMap _tlOnt = rule508 _lhsInt _tlOo_case = rule509 _lhsIo_case _tlOo_cata = rule510 _lhsIo_cata _tlOo_dovisit = rule511 _lhsIo_dovisit _tlOo_newtypes = rule512 _lhsIo_newtypes _tlOo_rename = rule513 _lhsIo_rename _tlOo_sem = rule514 _lhsIo_sem _tlOo_sig = rule515 _lhsIo_sig _tlOo_wantvisit = rule516 _lhsIo_wantvisit _tlOprefix = rule517 _lhsIprefix _tlOsyn = rule518 _lhsIsyn _tlOsynsOfChildren = rule519 _lhsIsynsOfChildren __result_ = T_Rules_vOut34 _lhsOdirectDep _lhsOerrors _lhsOgathAltAttrs _lhsOgathRules _lhsOinstDep _lhsOinstVars _lhsOlocVars _lhsOnAutoRules _lhsOnExplicitRules in __result_ ) in C_Rules_s35 v34 {-# INLINE rule465 #-} rule465 = \ ((_hdIdirectDep) :: Seq Edge) ((_tlIdirectDep) :: Seq Edge) -> _hdIdirectDep Seq.>< _tlIdirectDep {-# INLINE rule466 #-} rule466 = \ ((_hdIerrors) :: Seq Error) ((_tlIerrors) :: Seq Error) -> _hdIerrors Seq.>< _tlIerrors {-# INLINE rule467 #-} rule467 = \ ((_hdIgathAltAttrs) :: [AltAttr]) ((_tlIgathAltAttrs) :: [AltAttr]) -> _hdIgathAltAttrs ++ _tlIgathAltAttrs {-# INLINE rule468 #-} rule468 = \ ((_hdIgathRules) :: Seq CRule) ((_tlIgathRules) :: Seq CRule) -> _hdIgathRules Seq.>< _tlIgathRules {-# INLINE rule469 #-} rule469 = \ ((_hdIinstDep) :: Seq Edge) ((_tlIinstDep) :: Seq Edge) -> _hdIinstDep Seq.>< _tlIinstDep {-# INLINE rule470 #-} rule470 = \ ((_hdIinstVars) :: [Identifier]) ((_tlIinstVars) :: [Identifier]) -> _hdIinstVars ++ _tlIinstVars {-# INLINE rule471 #-} rule471 = \ ((_hdIlocVars) :: [Identifier]) ((_tlIlocVars) :: [Identifier]) -> _hdIlocVars ++ _tlIlocVars {-# INLINE rule472 #-} rule472 = \ ((_hdInAutoRules) :: Int) ((_tlInAutoRules) :: Int) -> _hdInAutoRules + _tlInAutoRules {-# INLINE rule473 #-} rule473 = \ ((_hdInExplicitRules) :: Int) ((_tlInExplicitRules) :: Int) -> _hdInExplicitRules + _tlInExplicitRules {-# INLINE rule474 #-} rule474 = \ ((_lhsIallTypeSigs) :: Map Identifier Type) -> _lhsIallTypeSigs {-# INLINE rule475 #-} rule475 = \ ((_lhsIallfields) :: [(Identifier,Type,ChildKind)]) -> _lhsIallfields {-# INLINE rule476 #-} rule476 = \ ((_lhsIallnts) :: [Identifier]) -> _lhsIallnts {-# INLINE rule477 #-} rule477 = \ ((_lhsIaltAttrs) :: Map AltAttr Vertex) -> _lhsIaltAttrs {-# INLINE rule478 #-} rule478 = \ ((_lhsIattrs) :: [(Identifier,Identifier)]) -> _lhsIattrs {-# INLINE rule479 #-} rule479 = \ ((_lhsIchildInhs) :: Map Identifier Attributes) -> _lhsIchildInhs {-# INLINE rule480 #-} rule480 = \ ((_lhsIchildNts) :: Map Identifier NontermIdent) -> _lhsIchildNts {-# INLINE rule481 #-} rule481 = \ ((_lhsIcon) :: Identifier) -> _lhsIcon {-# INLINE rule482 #-} rule482 = \ ((_lhsIinh) :: Attributes) -> _lhsIinh {-# INLINE rule483 #-} rule483 = \ ((_lhsIinhsOfChildren) :: Map Identifier Attributes) -> _lhsIinhsOfChildren {-# INLINE rule484 #-} rule484 = \ ((_lhsImergeMap) :: Map Identifier (Identifier,[Identifier])) -> _lhsImergeMap {-# INLINE rule485 #-} rule485 = \ ((_lhsInt) :: Identifier) -> _lhsInt {-# INLINE rule486 #-} rule486 = \ ((_lhsIo_case) :: Bool) -> _lhsIo_case {-# INLINE rule487 #-} rule487 = \ ((_lhsIo_cata) :: Bool) -> _lhsIo_cata {-# INLINE rule488 #-} rule488 = \ ((_lhsIo_dovisit) :: Bool) -> _lhsIo_dovisit {-# INLINE rule489 #-} rule489 = \ ((_lhsIo_newtypes) :: Bool) -> _lhsIo_newtypes {-# INLINE rule490 #-} rule490 = \ ((_lhsIo_rename) :: Bool) -> _lhsIo_rename {-# INLINE rule491 #-} rule491 = \ ((_lhsIo_sem) :: Bool) -> _lhsIo_sem {-# INLINE rule492 #-} rule492 = \ ((_lhsIo_sig) :: Bool) -> _lhsIo_sig {-# INLINE rule493 #-} rule493 = \ ((_lhsIo_wantvisit) :: Bool) -> _lhsIo_wantvisit {-# INLINE rule494 #-} rule494 = \ ((_lhsIprefix) :: String) -> _lhsIprefix {-# INLINE rule495 #-} rule495 = \ ((_lhsIsyn) :: Attributes) -> _lhsIsyn {-# INLINE rule496 #-} rule496 = \ ((_lhsIsynsOfChildren) :: Map Identifier Attributes) -> _lhsIsynsOfChildren {-# INLINE rule497 #-} rule497 = \ ((_lhsIallTypeSigs) :: Map Identifier Type) -> _lhsIallTypeSigs {-# INLINE rule498 #-} rule498 = \ ((_lhsIallfields) :: [(Identifier,Type,ChildKind)]) -> _lhsIallfields {-# INLINE rule499 #-} rule499 = \ ((_lhsIallnts) :: [Identifier]) -> _lhsIallnts {-# INLINE rule500 #-} rule500 = \ ((_lhsIaltAttrs) :: Map AltAttr Vertex) -> _lhsIaltAttrs {-# INLINE rule501 #-} rule501 = \ ((_lhsIattrs) :: [(Identifier,Identifier)]) -> _lhsIattrs {-# INLINE rule502 #-} rule502 = \ ((_lhsIchildInhs) :: Map Identifier Attributes) -> _lhsIchildInhs {-# INLINE rule503 #-} rule503 = \ ((_lhsIchildNts) :: Map Identifier NontermIdent) -> _lhsIchildNts {-# INLINE rule504 #-} rule504 = \ ((_lhsIcon) :: Identifier) -> _lhsIcon {-# INLINE rule505 #-} rule505 = \ ((_lhsIinh) :: Attributes) -> _lhsIinh {-# INLINE rule506 #-} rule506 = \ ((_lhsIinhsOfChildren) :: Map Identifier Attributes) -> _lhsIinhsOfChildren {-# INLINE rule507 #-} rule507 = \ ((_lhsImergeMap) :: Map Identifier (Identifier,[Identifier])) -> _lhsImergeMap {-# INLINE rule508 #-} rule508 = \ ((_lhsInt) :: Identifier) -> _lhsInt {-# INLINE rule509 #-} rule509 = \ ((_lhsIo_case) :: Bool) -> _lhsIo_case {-# INLINE rule510 #-} rule510 = \ ((_lhsIo_cata) :: Bool) -> _lhsIo_cata {-# INLINE rule511 #-} rule511 = \ ((_lhsIo_dovisit) :: Bool) -> _lhsIo_dovisit {-# INLINE rule512 #-} rule512 = \ ((_lhsIo_newtypes) :: Bool) -> _lhsIo_newtypes {-# INLINE rule513 #-} rule513 = \ ((_lhsIo_rename) :: Bool) -> _lhsIo_rename {-# INLINE rule514 #-} rule514 = \ ((_lhsIo_sem) :: Bool) -> _lhsIo_sem {-# INLINE rule515 #-} rule515 = \ ((_lhsIo_sig) :: Bool) -> _lhsIo_sig {-# INLINE rule516 #-} rule516 = \ ((_lhsIo_wantvisit) :: Bool) -> _lhsIo_wantvisit {-# INLINE rule517 #-} rule517 = \ ((_lhsIprefix) :: String) -> _lhsIprefix {-# INLINE rule518 #-} rule518 = \ ((_lhsIsyn) :: Attributes) -> _lhsIsyn {-# INLINE rule519 #-} rule519 = \ ((_lhsIsynsOfChildren) :: Map Identifier Attributes) -> _lhsIsynsOfChildren {-# NOINLINE sem_Rules_Nil #-} sem_Rules_Nil :: T_Rules sem_Rules_Nil = T_Rules (return st35) where {-# NOINLINE st35 #-} st35 = let v34 :: T_Rules_v34 v34 = \ (T_Rules_vIn34 _lhsIallTypeSigs _lhsIallfields _lhsIallnts _lhsIaltAttrs _lhsIattrs _lhsIchildInhs _lhsIchildNts _lhsIcon _lhsIinh _lhsIinhsOfChildren _lhsImergeMap _lhsInt _lhsIo_case _lhsIo_cata _lhsIo_dovisit _lhsIo_newtypes _lhsIo_rename _lhsIo_sem _lhsIo_sig _lhsIo_wantvisit _lhsIprefix _lhsIsyn _lhsIsynsOfChildren) -> ( let _lhsOdirectDep :: Seq Edge _lhsOdirectDep = rule520 () _lhsOerrors :: Seq Error _lhsOerrors = rule521 () _lhsOgathAltAttrs :: [AltAttr] _lhsOgathAltAttrs = rule522 () _lhsOgathRules :: Seq CRule _lhsOgathRules = rule523 () _lhsOinstDep :: Seq Edge _lhsOinstDep = rule524 () _lhsOinstVars :: [Identifier] _lhsOinstVars = rule525 () _lhsOlocVars :: [Identifier] _lhsOlocVars = rule526 () _lhsOnAutoRules :: Int _lhsOnAutoRules = rule527 () _lhsOnExplicitRules :: Int _lhsOnExplicitRules = rule528 () __result_ = T_Rules_vOut34 _lhsOdirectDep _lhsOerrors _lhsOgathAltAttrs _lhsOgathRules _lhsOinstDep _lhsOinstVars _lhsOlocVars _lhsOnAutoRules _lhsOnExplicitRules in __result_ ) in C_Rules_s35 v34 {-# INLINE rule520 #-} rule520 = \ (_ :: ()) -> Seq.empty {-# INLINE rule521 #-} rule521 = \ (_ :: ()) -> Seq.empty {-# INLINE rule522 #-} rule522 = \ (_ :: ()) -> [] {-# INLINE rule523 #-} rule523 = \ (_ :: ()) -> Seq.empty {-# INLINE rule524 #-} rule524 = \ (_ :: ()) -> Seq.empty {-# INLINE rule525 #-} rule525 = \ (_ :: ()) -> [] {-# INLINE rule526 #-} rule526 = \ (_ :: ()) -> [] {-# INLINE rule527 #-} rule527 = \ (_ :: ()) -> 0 {-# INLINE rule528 #-} rule528 = \ (_ :: ()) -> 0 -- TypeSig ----------------------------------------------------- -- wrapper data Inh_TypeSig = Inh_TypeSig { typeSigs_Inh_TypeSig :: (Map Identifier Type) } data Syn_TypeSig = Syn_TypeSig { typeSigs_Syn_TypeSig :: (Map Identifier Type) } {-# INLINABLE wrap_TypeSig #-} wrap_TypeSig :: T_TypeSig -> Inh_TypeSig -> (Syn_TypeSig ) wrap_TypeSig (T_TypeSig act) (Inh_TypeSig _lhsItypeSigs) = Control.Monad.Identity.runIdentity ( do sem <- act let arg = T_TypeSig_vIn37 _lhsItypeSigs (T_TypeSig_vOut37 _lhsOtypeSigs) <- return (inv_TypeSig_s38 sem arg) return (Syn_TypeSig _lhsOtypeSigs) ) -- cata {-# INLINE sem_TypeSig #-} sem_TypeSig :: TypeSig -> T_TypeSig sem_TypeSig ( TypeSig name_ tp_ ) = sem_TypeSig_TypeSig name_ tp_ -- semantic domain newtype T_TypeSig = T_TypeSig { attach_T_TypeSig :: Identity (T_TypeSig_s38 ) } newtype T_TypeSig_s38 = C_TypeSig_s38 { inv_TypeSig_s38 :: (T_TypeSig_v37 ) } data T_TypeSig_s39 = C_TypeSig_s39 type T_TypeSig_v37 = (T_TypeSig_vIn37 ) -> (T_TypeSig_vOut37 ) data T_TypeSig_vIn37 = T_TypeSig_vIn37 (Map Identifier Type) data T_TypeSig_vOut37 = T_TypeSig_vOut37 (Map Identifier Type) {-# NOINLINE sem_TypeSig_TypeSig #-} sem_TypeSig_TypeSig :: (Identifier) -> (Type) -> T_TypeSig sem_TypeSig_TypeSig arg_name_ arg_tp_ = T_TypeSig (return st38) where {-# NOINLINE st38 #-} st38 = let v37 :: T_TypeSig_v37 v37 = \ (T_TypeSig_vIn37 _lhsItypeSigs) -> ( let _lhsOtypeSigs :: Map Identifier Type _lhsOtypeSigs = rule529 _lhsItypeSigs arg_name_ arg_tp_ __result_ = T_TypeSig_vOut37 _lhsOtypeSigs in __result_ ) in C_TypeSig_s38 v37 {-# INLINE rule529 #-} {-# LINE 532 "./src-ag/Order.ag" #-} rule529 = \ ((_lhsItypeSigs) :: Map Identifier Type) name_ tp_ -> {-# LINE 532 "./src-ag/Order.ag" #-} Map.insert name_ tp_ _lhsItypeSigs {-# LINE 3734 "dist/build/Order.hs"#-} -- TypeSigs ---------------------------------------------------- -- wrapper data Inh_TypeSigs = Inh_TypeSigs { typeSigs_Inh_TypeSigs :: (Map Identifier Type) } data Syn_TypeSigs = Syn_TypeSigs { typeSigs_Syn_TypeSigs :: (Map Identifier Type) } {-# INLINABLE wrap_TypeSigs #-} wrap_TypeSigs :: T_TypeSigs -> Inh_TypeSigs -> (Syn_TypeSigs ) wrap_TypeSigs (T_TypeSigs act) (Inh_TypeSigs _lhsItypeSigs) = Control.Monad.Identity.runIdentity ( do sem <- act let arg = T_TypeSigs_vIn40 _lhsItypeSigs (T_TypeSigs_vOut40 _lhsOtypeSigs) <- return (inv_TypeSigs_s41 sem arg) return (Syn_TypeSigs _lhsOtypeSigs) ) -- cata {-# NOINLINE sem_TypeSigs #-} sem_TypeSigs :: TypeSigs -> T_TypeSigs sem_TypeSigs list = Prelude.foldr sem_TypeSigs_Cons sem_TypeSigs_Nil (Prelude.map sem_TypeSig list) -- semantic domain newtype T_TypeSigs = T_TypeSigs { attach_T_TypeSigs :: Identity (T_TypeSigs_s41 ) } newtype T_TypeSigs_s41 = C_TypeSigs_s41 { inv_TypeSigs_s41 :: (T_TypeSigs_v40 ) } data T_TypeSigs_s42 = C_TypeSigs_s42 type T_TypeSigs_v40 = (T_TypeSigs_vIn40 ) -> (T_TypeSigs_vOut40 ) data T_TypeSigs_vIn40 = T_TypeSigs_vIn40 (Map Identifier Type) data T_TypeSigs_vOut40 = T_TypeSigs_vOut40 (Map Identifier Type) {-# NOINLINE sem_TypeSigs_Cons #-} sem_TypeSigs_Cons :: T_TypeSig -> T_TypeSigs -> T_TypeSigs sem_TypeSigs_Cons arg_hd_ arg_tl_ = T_TypeSigs (return st41) where {-# NOINLINE st41 #-} st41 = let v40 :: T_TypeSigs_v40 v40 = \ (T_TypeSigs_vIn40 _lhsItypeSigs) -> ( let _hdX38 = Control.Monad.Identity.runIdentity (attach_T_TypeSig (arg_hd_)) _tlX41 = Control.Monad.Identity.runIdentity (attach_T_TypeSigs (arg_tl_)) (T_TypeSig_vOut37 _hdItypeSigs) = inv_TypeSig_s38 _hdX38 (T_TypeSig_vIn37 _hdOtypeSigs) (T_TypeSigs_vOut40 _tlItypeSigs) = inv_TypeSigs_s41 _tlX41 (T_TypeSigs_vIn40 _tlOtypeSigs) _lhsOtypeSigs :: Map Identifier Type _lhsOtypeSigs = rule530 _tlItypeSigs _hdOtypeSigs = rule531 _lhsItypeSigs _tlOtypeSigs = rule532 _hdItypeSigs __result_ = T_TypeSigs_vOut40 _lhsOtypeSigs in __result_ ) in C_TypeSigs_s41 v40 {-# INLINE rule530 #-} rule530 = \ ((_tlItypeSigs) :: Map Identifier Type) -> _tlItypeSigs {-# INLINE rule531 #-} rule531 = \ ((_lhsItypeSigs) :: Map Identifier Type) -> _lhsItypeSigs {-# INLINE rule532 #-} rule532 = \ ((_hdItypeSigs) :: Map Identifier Type) -> _hdItypeSigs {-# NOINLINE sem_TypeSigs_Nil #-} sem_TypeSigs_Nil :: T_TypeSigs sem_TypeSigs_Nil = T_TypeSigs (return st41) where {-# NOINLINE st41 #-} st41 = let v40 :: T_TypeSigs_v40 v40 = \ (T_TypeSigs_vIn40 _lhsItypeSigs) -> ( let _lhsOtypeSigs :: Map Identifier Type _lhsOtypeSigs = rule533 _lhsItypeSigs __result_ = T_TypeSigs_vOut40 _lhsOtypeSigs in __result_ ) in C_TypeSigs_s41 v40 {-# INLINE rule533 #-} rule533 = \ ((_lhsItypeSigs) :: Map Identifier Type) -> _lhsItypeSigs