-- UUAGC 0.9.11 (AstInternal.ag) module Database.HsSqlPpp.AstInternals.AstInternal( -- {-# LANGUAGE DeriveDataTypeable,RankNTypes,ScopedTypeVariables #-} -- {-# OPTIONS_HADDOCK hide #-} --from the ag files: --ast nodes Statement (..) ,SelectExpression (..) ,FnBody (..) ,SetClause (..) ,TableRef (..) ,TableAlias(..) ,JoinExpression (..) ,JoinType (..) ,SelectList (..) ,SelectItem (..) ,CopySource (..) ,AttributeDef (..) ,RowConstraint (..) ,AlterTableAction(..) ,Constraint (..) ,TypeAttributeDef (..) ,ParamDef (..) ,VarDef (..) ,RaiseType (..) ,CombineType (..) ,Volatility (..) ,Language (..) ,TypeName (..) ,DropType (..) ,Cascade (..) ,Direction (..) ,Distinct (..) ,Natural (..) ,IfExists (..) ,RestartIdentity (..) ,Expression (..) ,FrameClause(..) ,InList (..) ,LiftFlavour(..) ,TriggerWhen(..) ,TriggerEvent(..) ,TriggerFire(..) ,StatementList ,ExpressionListStatementListPairList ,ExpressionListStatementListPair ,ExpressionList ,StringList ,ParamDefList ,AttributeDefList ,ConstraintList ,TypeAttributeDefList ,TypeNameList ,StringTypeNameListPair ,StringTypeNameListPairList ,ExpressionStatementListPairList ,SetClauseList ,CaseExpressionListExpressionPairList ,MaybeExpression ,TableRefList ,ExpressionListList ,SelectItemList ,OnExpr ,RowConstraintList ,VarDefList ,ExpressionStatementListPair ,CaseExpressionListExpressionPair ,CaseExpressionList ,ExpressionDirectionPair ,ExpressionDirectionPairList ,MaybeBoolExpression ,MaybeSelectList ,SetValue(..) -- typechecking ,typeCheck ,typeCheckPS ,typeCheckExpression ) where import Data.Maybe import Data.List import Debug.Trace import Control.Monad.Error import Control.Arrow import Data.Either import Control.Applicative import Data.Generics import Data.Char import Database.HsSqlPpp.AstInternals.TypeType import Database.HsSqlPpp.AstInternals.TypeChecking.TypeConversion import Database.HsSqlPpp.AstInternals.TypeChecking.ErrorUtils import Database.HsSqlPpp.AstInternals.AstAnnotation import Database.HsSqlPpp.AstInternals.Environment.EnvironmentInternal import Database.HsSqlPpp.AstInternals.Environment.LocalIdentifierBindings import Database.HsSqlPpp.AstInternals.Environment.DefaultTemplate1Environment import Database.HsSqlPpp.Utils import Data.Generics.PlateData {-# LINE 683 "AstInternal.ag" #-} {- -- | Type check multiple asts, allowing type checking references in -- later files to definitions in earlier files. This is probably -- more straightforward if you parse the files then concatenate the -- statementlists together before type checking rather than using -- this function typeCheckMany :: Environment -> [StatementList] -> [StatementList] typeCheckMany env sts = annInt env sts [] where annInt e (s:ss) ress = let (e1,res) = typeCheck e s in annInt e1 ss (res:ress) annInt _ [] ress = reverse ress -} -- | Takes an ast, checks against catalog passed, and adds -- annotations, including types, type errors, and statement info. -- Returns the updated catalog as well as the annotated ast. typeCheck :: Environment -> StatementList -> (Environment,StatementList) typeCheck env sts = let t = sem_Root (Root (fixupImplicitJoins sts)) ta = wrap_Root t Inh_Root {env_Inh_Root = env ,lib_Inh_Root = emptyBindings} tl = annotatedTree_Syn_Root ta env1 = producedEnv_Syn_Root ta in case tl of Root r -> (env1,r) -- | Unfinished version of type check which can type check an -- individual statement with ? or positional arg placeholders in -- it. Will error if the statement isn't select, update, insert or -- delete. For use in type checking embedded parameterized -- statements. Does all typechecking and annotation that the regular -- typecheck does. typeCheckPS :: Environment -> Statement -> Either String Statement typeCheckPS env st = case st of SelectStatement _ _ -> tc Insert _ _ _ _ _ -> tc Update _ _ _ _ _ -> tc Delete _ _ _ _ -> tc _ -> Left "requires select, update, insert or delete statement" where tc = let t = sem_Root (Root (fixupImplicitJoins [st])) ta = wrap_Root t Inh_Root {env_Inh_Root = env ,lib_Inh_Root = emptyBindings} tl = annotatedTree_Syn_Root ta env1 = producedEnv_Syn_Root ta in case tl of Root [st1] -> Right st1 _ -> error "impossible happened in typeCheckPS!" -- | Testing utility, mainly used to check an expression for type errors -- or to get its type. typeCheckExpression :: Environment -> Expression -> Expression typeCheckExpression env ex = let t = sem_ExpressionRoot (ExpressionRoot (fixupImplicitJoins ex)) rt = (annotatedTree_Syn_ExpressionRoot (wrap_ExpressionRoot t Inh_ExpressionRoot {env_Inh_ExpressionRoot = env ,lib_Inh_ExpressionRoot = emptyBindings})) in case rt of ExpressionRoot e -> e {- bit of a hack, to avoid rewriting the tableref type checking to be able to do implicit joins, we just convert them in to the equivalent explicit join -} fixupImplicitJoins :: Data a => a -> a fixupImplicitJoins = transformBi $ \x -> case x of -- alter asts to change implicit joins into explicit joins Select an dis sl trs@(_:_:_) whr grp hav ord lim off -> Select an dis sl [convTrefs trs] whr grp hav ord lim off x1 -> x1 where convTrefs (tr:tr1:trs) = JoinedTref [] tr Unnatural Cross (convTrefs (tr1:trs)) Nothing NoAlias convTrefs (tr:[]) = tr convTrefs _ = error "failed doing implicit join fixup hack" {-# LINE 189 "AstInternal.hs" #-} {-# LINE 81 "./TypeChecking/Misc.ag" #-} {- ================================================================================ = couple of small utils I think this should be alright, an identifier referenced in an expression can only have zero or one dot in it. -} splitIdentifier :: String -> (String,String) splitIdentifier s = let (a,b) = span (/= '.') s in if b == "" then ("", a) else (a,tail b) {- helper to make adding annotations a bit easier -} annTypesAndErrors :: Data a => a -> Type -> [TypeError] -> Maybe [AnnotationElement] -> a annTypesAndErrors item nt errs add = updateAnnotation modifier item where modifier = (([TypeAnnotation nt] ++ fromMaybe [] add ++ map TypeErrorA errs) ++) {-# LINE 220 "AstInternal.hs" #-} {-# LINE 78 "./TypeChecking/Expressions.ag" #-} {- small shim in front of findCallMatch in the type conversion code, to handle some special cases. Some of the special cases will no longer be needed when variadic support is added. between, greatest and least are treated as syntactic sugar so we delegate the function lookups to the <=/>= operators. the row comparison should be more general than this, since it supports any operator satisfying some properties TODO: move all of this into find call match. Don't know why it's separate -} typeCheckFunCall :: Environment -> String -> [Type] -> Either [TypeError] Type typeCheckFunCall env fnName' argsType = {-trace ("typecheckfncall " ++ fnName' ++ show argsType) $-} dependsOnRTpe argsType $ case fnName of "count" -> -- not quite sure how this is suppose to work, -- the counts in the pg catalog accept either -- no args, or one arg of type any, but you can call -- count with multiple arguments? return typeBigInt "!between" -> do f1 <- lookupFn ">=" [argsType !! 0, argsType !! 1] f2 <- lookupFn "<=" [argsType !! 0, argsType !! 2] lookupFn "!and" [f1,f2] --"coalesce" -> resolveResultSetType env argsType "greatest" -> do t <- lookupFn fnName argsType -- t <- resolveResultSetType env argsType lookupFn ">=" [t,t] return t "least" -> do t <- lookupFn fnName argsType -- resolveResultSetType env argsType lookupFn "<=" [t,t] return t "!rowctor" -> return $ AnonymousRecordType argsType -- special case the row comparison ops -- this needs to be fixed: we want to match -- any implicit casts to functions on composite types -- first, then we can use the anonymous record type on -- any composite _ | fnName `elem` ["=", "<>", "<=", ">=", "<", ">"] && length argsType == 2 && all isCompositeOrSetOfCompositeType argsType && compositesCompatible env (head argsType) (head $ tail argsType) -> Right typeBool --checked for all special cases, so run general case now s -> lookupFn s argsType where lookupFn :: String -> [Type] -> Either [TypeError] Type lookupFn s1 args = do (_,_,r,_) <- findCallMatch env (if s1 == "u-" then "-" else s1) args return r checkRowTypesMatch (AnonymousRecordType t1s) (AnonymousRecordType t2s) = do when (length t1s /= length t2s) $ Left [ValuesListsMustBeSameLength] let errs = map (resolveResultSetType env . (\(a,b) -> [a,b])) $ zip t1s t2s liftErrors $ concat $ lefts errs return typeBool checkRowTypesMatch x y = error $ "internal error: checkRowTypesMatch called with " ++ show x ++ "," ++ show y fnName = map toLower fnName' {-# LINE 292 "AstInternal.hs" #-} {-# LINE 141 "./TypeChecking/SelectStatement.ag" #-} typeCheckValuesExpr :: Environment -> [[Type]] -> Either [TypeError] Type typeCheckValuesExpr env rowsTs = let colNames = zipWith (++) (repeat "column") (map show [1..length $ head rowsTs]) in unionRelTypes env rowsTs colNames typeCheckCombineSelect :: Environment -> Type -> Type -> Either [TypeError] Type typeCheckCombineSelect env v1 v2 = do u1 <- unwrapSetOfComposite v1 let colNames = map fst u1 u2 <- unwrapSetOfComposite v2 let colTypes1 = map snd u1 let colTypes2 = map snd u2 unionRelTypes env [colTypes1,colTypes2] colNames unionRelTypes :: Environment -> [[Type]] -> [String] -> Either [TypeError] Type unionRelTypes env rowsTs colNames = let lengths = map length rowsTs in case () of _ | null rowsTs -> Left [NoRowsGivenForValues] | not (all (==head lengths) lengths) -> Left [ValuesListsMustBeSameLength] | otherwise -> --i don't think this propagates all the errors, just the first set mapM (resolveResultSetType env) (transpose rowsTs) >>= (return . SetOfType . CompositeType . zip colNames) {-# LINE 327 "AstInternal.hs" #-} {-# LINE 180 "./TypeChecking/SelectStatement.ag" #-} getPlaceholders :: Data a => a -> [Expression] getPlaceholders st = filter isPlaceholder $ everything (++) (mkQ [] ga) st where ga :: Expression -> [Expression] ga s = [s] isPlaceholder e = case e of PositionalArg _ _ -> True Placeholder _ -> True _ -> False {-# LINE 341 "AstInternal.hs" #-} {-# LINE 200 "./TypeChecking/TableRefs.ag" #-} {- convert a function call into a [String,[(string,type)]] list for use in a tableref context first consideration is the alias: if there is an alias in the select, e.g. select * from generate_series(1,2) x; (alias is x) we use that, otherwise we use the name of the function second consideration is the attributes coming out, roughly speaking we have to convert an arbitrary type to a relation type if we have a relation valued function, we don't need to do anything if we have a setof non composite, we lift the single type to an attribute, using the function name for the attribute name if we have a non setof, we lift the single type to an attribute and then relation, using the function name for the attribute name need to check to see what should happen with arrayof -} funIdens :: Environment -> String -> Expression -> Either [TypeError] (String,[(String,Type)]) funIdens env alias fnVal = do errorWhen (case fnVal of FunCall _ _ _ -> False _ -> True) [ContextError "FunCall"] let (FunCall _ fnName _) = fnVal correlationName = if alias /= "" then alias else fnName attrs <- do case getTypeAnnotation fnVal of SetOfType (NamedCompositeType t) -> envCompositePublicAttrs env [] t SetOfType x -> return [(correlationName,x)] y -> return [(correlationName,y)] return (correlationName, attrs) getAlias :: String -> TableAlias -> String getAlias def alias = case alias of NoAlias -> def TableAlias t -> t FullAlias t _ -> t {-# LINE 385 "AstInternal.hs" #-} {-# LINE 92 "./TypeChecking/SelectLists.ag" #-} expandStar :: LocalIdentifierBindings -> String -> Type -> [(String,Type)] -> [(String,Type)] expandStar env colName colType types = fromRight types $ do let (correlationName,iden) = splitIdentifier colName newCols <- if iden == "*" then libExpandStar env correlationName else return [(iden, colType)] return $ newCols ++ types fixStar :: Expression -> Expression fixStar = everywhere (mkT fixStar') where fixStar' :: Annotation -> Annotation fixStar' a = if TypeAnnotation TypeCheckFailed `elem` a && any (\an -> case an of TypeErrorA (UnrecognisedIdentifier x) | let (_,iden) = splitIdentifier x in iden == "*" -> True _ -> False) a then filter (\an -> case an of TypeAnnotation TypeCheckFailed -> False TypeErrorA (UnrecognisedIdentifier _) -> False _ -> True) a else a {-# LINE 420 "AstInternal.hs" #-} {-# LINE 136 "./TypeChecking/Dml.ag" #-} getRowTypes :: [Type] -> [Type] getRowTypes [AnonymousRecordType ts] = ts getRowTypes ts = ts {-# LINE 427 "AstInternal.hs" #-} {-# LINE 174 "./TypeChecking/Dml.ag" #-} --small shortcut to help produce better errors? checkRelationExists :: Environment -> String -> Either [TypeError] () checkRelationExists env tbl = envCompositeDef env relationComposites tbl >> return () --used by both insert and update checkColumnConsistency :: Environment -> String -> [String] -> [(String,Type)] -> Either [TypeError] [(String,Type)] checkColumnConsistency env tbl cols' insNameTypePairs = do ttcols <- lowerize <$> envCompositePublicAttrs env [] tbl let cols = if null cols' then map fst ttcols else map (map toLower) cols' errorWhen (length insNameTypePairs /= length cols) [WrongNumberOfColumns] let nonMatchingColumns = cols \\ map fst ttcols errorWhen (not $ null nonMatchingColumns) $ map UnrecognisedIdentifier nonMatchingColumns let targetNameTypePairs = map (\l -> (l,fromJust $ lookup l ttcols)) cols --check the types of the insdata match the column targets --name datatype columntype typeTriples = map (\((a,b),c) -> (a,b,c)) $ zip targetNameTypePairs $ map snd insNameTypePairs errs :: [TypeError] errs = concat $ lefts $ map (\(_,b,c) -> checkAssignmentValid env c b) typeTriples liftErrors errs return targetNameTypePairs where lowerize = map (\(a,b) -> (map toLower a,b)) {-# LINE 464 "AstInternal.hs" #-} {-# LINE 40 "./TypeChecking/CreateTable.ag" #-} defaultSystemColumns :: [(String,Type)] defaultSystemColumns = [("tableoid", ScalarType "oid") ,("cmax", ScalarType "cid") ,("xmax", ScalarType "xid") ,("cmin", ScalarType "cid") ,("xmin", ScalarType "xid") ,("ctid", ScalarType "tid")] {-# LINE 475 "AstInternal.hs" #-} -- AlterTableAction -------------------------------------------- {- visit 0: inherited attributes: env : Environment lib : LocalIdentifierBindings synthesized attributes: annotatedTree : SELF originalTree : SELF alternatives: alternative AddConstraint: child ann : {Annotation} child con : Constraint visit 0: local annotatedTree : _ local originalTree : _ alternative AlterColumnDefault: child ann : {Annotation} child nm : {String} child def : Expression visit 0: local annotatedTree : _ local originalTree : _ -} data AlterTableAction = AddConstraint (Annotation) (Constraint) | AlterColumnDefault (Annotation) (String) (Expression) deriving ( Data,Eq,Show,Typeable) -- cata sem_AlterTableAction :: AlterTableAction -> T_AlterTableAction sem_AlterTableAction (AddConstraint _ann _con ) = (sem_AlterTableAction_AddConstraint _ann (sem_Constraint _con ) ) sem_AlterTableAction (AlterColumnDefault _ann _nm _def ) = (sem_AlterTableAction_AlterColumnDefault _ann _nm (sem_Expression _def ) ) -- semantic domain type T_AlterTableAction = Environment -> LocalIdentifierBindings -> ( AlterTableAction,AlterTableAction) data Inh_AlterTableAction = Inh_AlterTableAction {env_Inh_AlterTableAction :: Environment,lib_Inh_AlterTableAction :: LocalIdentifierBindings} data Syn_AlterTableAction = Syn_AlterTableAction {annotatedTree_Syn_AlterTableAction :: AlterTableAction,originalTree_Syn_AlterTableAction :: AlterTableAction} wrap_AlterTableAction :: T_AlterTableAction -> Inh_AlterTableAction -> Syn_AlterTableAction wrap_AlterTableAction sem (Inh_AlterTableAction _lhsIenv _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIenv _lhsIlib ) in (Syn_AlterTableAction _lhsOannotatedTree _lhsOoriginalTree )) sem_AlterTableAction_AddConstraint :: Annotation -> T_Constraint -> T_AlterTableAction sem_AlterTableAction_AddConstraint ann_ con_ = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: AlterTableAction _lhsOoriginalTree :: AlterTableAction _conOenv :: Environment _conOlib :: LocalIdentifierBindings _conIannotatedTree :: Constraint _conIoriginalTree :: Constraint -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} AddConstraint ann_ _conIannotatedTree {-# LINE 539 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} AddConstraint ann_ _conIoriginalTree {-# LINE 544 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 549 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 554 "AstInternal.hs" #-} -- copy rule (down) _conOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 559 "AstInternal.hs" #-} -- copy rule (down) _conOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 564 "AstInternal.hs" #-} ( _conIannotatedTree,_conIoriginalTree) = (con_ _conOenv _conOlib ) in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_AlterTableAction_AlterColumnDefault :: Annotation -> String -> T_Expression -> T_AlterTableAction sem_AlterTableAction_AlterColumnDefault ann_ nm_ def_ = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: AlterTableAction _lhsOoriginalTree :: AlterTableAction _defOenv :: Environment _defOlib :: LocalIdentifierBindings _defIannotatedTree :: Expression _defIliftedColumnName :: String _defIoriginalTree :: Expression -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} AlterColumnDefault ann_ nm_ _defIannotatedTree {-# LINE 586 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} AlterColumnDefault ann_ nm_ _defIoriginalTree {-# LINE 591 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 596 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 601 "AstInternal.hs" #-} -- copy rule (down) _defOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 606 "AstInternal.hs" #-} -- copy rule (down) _defOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 611 "AstInternal.hs" #-} ( _defIannotatedTree,_defIliftedColumnName,_defIoriginalTree) = (def_ _defOenv _defOlib ) in ( _lhsOannotatedTree,_lhsOoriginalTree))) -- AttributeDef ------------------------------------------------ {- visit 0: inherited attributes: env : Environment lib : LocalIdentifierBindings synthesized attributes: annotatedTree : SELF attrName : String namedType : Type originalTree : SELF alternatives: alternative AttributeDef: child ann : {Annotation} child name : {String} child typ : TypeName child def : MaybeExpression child cons : RowConstraintList visit 0: local annotatedTree : _ local originalTree : _ -} data AttributeDef = AttributeDef (Annotation) (String) (TypeName) (MaybeExpression) (RowConstraintList) deriving ( Data,Eq,Show,Typeable) -- cata sem_AttributeDef :: AttributeDef -> T_AttributeDef sem_AttributeDef (AttributeDef _ann _name _typ _def _cons ) = (sem_AttributeDef_AttributeDef _ann _name (sem_TypeName _typ ) (sem_MaybeExpression _def ) (sem_RowConstraintList _cons ) ) -- semantic domain type T_AttributeDef = Environment -> LocalIdentifierBindings -> ( AttributeDef,String,Type,AttributeDef) data Inh_AttributeDef = Inh_AttributeDef {env_Inh_AttributeDef :: Environment,lib_Inh_AttributeDef :: LocalIdentifierBindings} data Syn_AttributeDef = Syn_AttributeDef {annotatedTree_Syn_AttributeDef :: AttributeDef,attrName_Syn_AttributeDef :: String,namedType_Syn_AttributeDef :: Type,originalTree_Syn_AttributeDef :: AttributeDef} wrap_AttributeDef :: T_AttributeDef -> Inh_AttributeDef -> Syn_AttributeDef wrap_AttributeDef sem (Inh_AttributeDef _lhsIenv _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOattrName,_lhsOnamedType,_lhsOoriginalTree) = (sem _lhsIenv _lhsIlib ) in (Syn_AttributeDef _lhsOannotatedTree _lhsOattrName _lhsOnamedType _lhsOoriginalTree )) sem_AttributeDef_AttributeDef :: Annotation -> String -> T_TypeName -> T_MaybeExpression -> T_RowConstraintList -> T_AttributeDef sem_AttributeDef_AttributeDef ann_ name_ typ_ def_ cons_ = (\ _lhsIenv _lhsIlib -> (let _lhsOattrName :: String _lhsOnamedType :: Type _consOlib :: LocalIdentifierBindings _lhsOannotatedTree :: AttributeDef _lhsOoriginalTree :: AttributeDef _typOenv :: Environment _typOlib :: LocalIdentifierBindings _defOenv :: Environment _defOlib :: LocalIdentifierBindings _consOenv :: Environment _typIannotatedTree :: TypeName _typInamedType :: Type _typIoriginalTree :: TypeName _defIannotatedTree :: MaybeExpression _defIoriginalTree :: MaybeExpression _consIannotatedTree :: RowConstraintList _consIoriginalTree :: RowConstraintList -- "./TypeChecking/CreateTable.ag"(line 79, column 9) _lhsOattrName = {-# LINE 79 "./TypeChecking/CreateTable.ag" #-} map toLower name_ {-# LINE 687 "AstInternal.hs" #-} -- "./TypeChecking/CreateTable.ag"(line 80, column 9) _lhsOnamedType = {-# LINE 80 "./TypeChecking/CreateTable.ag" #-} _typInamedType {-# LINE 692 "AstInternal.hs" #-} -- "./TypeChecking/CreateTable.ag"(line 95, column 9) _consOlib = {-# LINE 95 "./TypeChecking/CreateTable.ag" #-} case updateBindings _lhsIlib _lhsIenv [LibStackIDs [("", [(name_, _typInamedType)])]] of Left x -> error $ show x Right e -> e {-# LINE 700 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} AttributeDef ann_ name_ _typIannotatedTree _defIannotatedTree _consIannotatedTree {-# LINE 705 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} AttributeDef ann_ name_ _typIoriginalTree _defIoriginalTree _consIoriginalTree {-# LINE 710 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 715 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 720 "AstInternal.hs" #-} -- copy rule (down) _typOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 725 "AstInternal.hs" #-} -- copy rule (down) _typOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 730 "AstInternal.hs" #-} -- copy rule (down) _defOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 735 "AstInternal.hs" #-} -- copy rule (down) _defOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 740 "AstInternal.hs" #-} -- copy rule (down) _consOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 745 "AstInternal.hs" #-} ( _typIannotatedTree,_typInamedType,_typIoriginalTree) = (typ_ _typOenv _typOlib ) ( _defIannotatedTree,_defIoriginalTree) = (def_ _defOenv _defOlib ) ( _consIannotatedTree,_consIoriginalTree) = (cons_ _consOenv _consOlib ) in ( _lhsOannotatedTree,_lhsOattrName,_lhsOnamedType,_lhsOoriginalTree))) -- AttributeDefList -------------------------------------------- {- visit 0: inherited attributes: env : Environment lib : LocalIdentifierBindings synthesized attributes: annotatedTree : SELF attrs : [(String, Type)] originalTree : SELF alternatives: alternative Cons: child hd : AttributeDef child tl : AttributeDefList visit 0: local annotatedTree : _ local originalTree : _ alternative Nil: visit 0: local annotatedTree : _ local originalTree : _ -} type AttributeDefList = [(AttributeDef)] -- cata sem_AttributeDefList :: AttributeDefList -> T_AttributeDefList sem_AttributeDefList list = (Prelude.foldr sem_AttributeDefList_Cons sem_AttributeDefList_Nil (Prelude.map sem_AttributeDef list) ) -- semantic domain type T_AttributeDefList = Environment -> LocalIdentifierBindings -> ( AttributeDefList,([(String, Type)]),AttributeDefList) data Inh_AttributeDefList = Inh_AttributeDefList {env_Inh_AttributeDefList :: Environment,lib_Inh_AttributeDefList :: LocalIdentifierBindings} data Syn_AttributeDefList = Syn_AttributeDefList {annotatedTree_Syn_AttributeDefList :: AttributeDefList,attrs_Syn_AttributeDefList :: [(String, Type)],originalTree_Syn_AttributeDefList :: AttributeDefList} wrap_AttributeDefList :: T_AttributeDefList -> Inh_AttributeDefList -> Syn_AttributeDefList wrap_AttributeDefList sem (Inh_AttributeDefList _lhsIenv _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOattrs,_lhsOoriginalTree) = (sem _lhsIenv _lhsIlib ) in (Syn_AttributeDefList _lhsOannotatedTree _lhsOattrs _lhsOoriginalTree )) sem_AttributeDefList_Cons :: T_AttributeDef -> T_AttributeDefList -> T_AttributeDefList sem_AttributeDefList_Cons hd_ tl_ = (\ _lhsIenv _lhsIlib -> (let _lhsOattrs :: ([(String, Type)]) _lhsOannotatedTree :: AttributeDefList _lhsOoriginalTree :: AttributeDefList _hdOenv :: Environment _hdOlib :: LocalIdentifierBindings _tlOenv :: Environment _tlOlib :: LocalIdentifierBindings _hdIannotatedTree :: AttributeDef _hdIattrName :: String _hdInamedType :: Type _hdIoriginalTree :: AttributeDef _tlIannotatedTree :: AttributeDefList _tlIattrs :: ([(String, Type)]) _tlIoriginalTree :: AttributeDefList -- "./TypeChecking/CreateTable.ag"(line 85, column 12) _lhsOattrs = {-# LINE 85 "./TypeChecking/CreateTable.ag" #-} (_hdIattrName, _hdInamedType) : _tlIattrs {-# LINE 818 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} (:) _hdIannotatedTree _tlIannotatedTree {-# LINE 823 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} (:) _hdIoriginalTree _tlIoriginalTree {-# LINE 828 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 833 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 838 "AstInternal.hs" #-} -- copy rule (down) _hdOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 843 "AstInternal.hs" #-} -- copy rule (down) _hdOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 848 "AstInternal.hs" #-} -- copy rule (down) _tlOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 853 "AstInternal.hs" #-} -- copy rule (down) _tlOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 858 "AstInternal.hs" #-} ( _hdIannotatedTree,_hdIattrName,_hdInamedType,_hdIoriginalTree) = (hd_ _hdOenv _hdOlib ) ( _tlIannotatedTree,_tlIattrs,_tlIoriginalTree) = (tl_ _tlOenv _tlOlib ) in ( _lhsOannotatedTree,_lhsOattrs,_lhsOoriginalTree))) sem_AttributeDefList_Nil :: T_AttributeDefList sem_AttributeDefList_Nil = (\ _lhsIenv _lhsIlib -> (let _lhsOattrs :: ([(String, Type)]) _lhsOannotatedTree :: AttributeDefList _lhsOoriginalTree :: AttributeDefList -- "./TypeChecking/CreateTable.ag"(line 86, column 11) _lhsOattrs = {-# LINE 86 "./TypeChecking/CreateTable.ag" #-} [] {-# LINE 875 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 880 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 885 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 890 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 895 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOattrs,_lhsOoriginalTree))) -- Cascade ----------------------------------------------------- {- visit 0: inherited attributes: env : Environment lib : LocalIdentifierBindings synthesized attributes: annotatedTree : SELF originalTree : SELF alternatives: alternative Cascade: visit 0: local annotatedTree : _ local originalTree : _ alternative Restrict: visit 0: local annotatedTree : _ local originalTree : _ -} data Cascade = Cascade | Restrict deriving ( Data,Eq,Show,Typeable) -- cata sem_Cascade :: Cascade -> T_Cascade sem_Cascade (Cascade ) = (sem_Cascade_Cascade ) sem_Cascade (Restrict ) = (sem_Cascade_Restrict ) -- semantic domain type T_Cascade = Environment -> LocalIdentifierBindings -> ( Cascade,Cascade) data Inh_Cascade = Inh_Cascade {env_Inh_Cascade :: Environment,lib_Inh_Cascade :: LocalIdentifierBindings} data Syn_Cascade = Syn_Cascade {annotatedTree_Syn_Cascade :: Cascade,originalTree_Syn_Cascade :: Cascade} wrap_Cascade :: T_Cascade -> Inh_Cascade -> Syn_Cascade wrap_Cascade sem (Inh_Cascade _lhsIenv _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIenv _lhsIlib ) in (Syn_Cascade _lhsOannotatedTree _lhsOoriginalTree )) sem_Cascade_Cascade :: T_Cascade sem_Cascade_Cascade = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: Cascade _lhsOoriginalTree :: Cascade -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Cascade {-# LINE 949 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Cascade {-# LINE 954 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 959 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 964 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_Cascade_Restrict :: T_Cascade sem_Cascade_Restrict = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: Cascade _lhsOoriginalTree :: Cascade -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Restrict {-# LINE 976 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Restrict {-# LINE 981 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 986 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 991 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) -- CaseExpressionList ------------------------------------------ {- visit 0: inherited attributes: env : Environment lib : LocalIdentifierBindings synthesized attributes: annotatedTree : SELF originalTree : SELF alternatives: alternative Cons: child hd : Expression child tl : CaseExpressionList visit 0: local annotatedTree : _ local originalTree : _ alternative Nil: visit 0: local annotatedTree : _ local originalTree : _ -} type CaseExpressionList = [(Expression)] -- cata sem_CaseExpressionList :: CaseExpressionList -> T_CaseExpressionList sem_CaseExpressionList list = (Prelude.foldr sem_CaseExpressionList_Cons sem_CaseExpressionList_Nil (Prelude.map sem_Expression list) ) -- semantic domain type T_CaseExpressionList = Environment -> LocalIdentifierBindings -> ( CaseExpressionList,CaseExpressionList) data Inh_CaseExpressionList = Inh_CaseExpressionList {env_Inh_CaseExpressionList :: Environment,lib_Inh_CaseExpressionList :: LocalIdentifierBindings} data Syn_CaseExpressionList = Syn_CaseExpressionList {annotatedTree_Syn_CaseExpressionList :: CaseExpressionList,originalTree_Syn_CaseExpressionList :: CaseExpressionList} wrap_CaseExpressionList :: T_CaseExpressionList -> Inh_CaseExpressionList -> Syn_CaseExpressionList wrap_CaseExpressionList sem (Inh_CaseExpressionList _lhsIenv _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIenv _lhsIlib ) in (Syn_CaseExpressionList _lhsOannotatedTree _lhsOoriginalTree )) sem_CaseExpressionList_Cons :: T_Expression -> T_CaseExpressionList -> T_CaseExpressionList sem_CaseExpressionList_Cons hd_ tl_ = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: CaseExpressionList _lhsOoriginalTree :: CaseExpressionList _hdOenv :: Environment _hdOlib :: LocalIdentifierBindings _tlOenv :: Environment _tlOlib :: LocalIdentifierBindings _hdIannotatedTree :: Expression _hdIliftedColumnName :: String _hdIoriginalTree :: Expression _tlIannotatedTree :: CaseExpressionList _tlIoriginalTree :: CaseExpressionList -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} (:) _hdIannotatedTree _tlIannotatedTree {-# LINE 1054 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} (:) _hdIoriginalTree _tlIoriginalTree {-# LINE 1059 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 1064 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 1069 "AstInternal.hs" #-} -- copy rule (down) _hdOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 1074 "AstInternal.hs" #-} -- copy rule (down) _hdOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 1079 "AstInternal.hs" #-} -- copy rule (down) _tlOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 1084 "AstInternal.hs" #-} -- copy rule (down) _tlOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 1089 "AstInternal.hs" #-} ( _hdIannotatedTree,_hdIliftedColumnName,_hdIoriginalTree) = (hd_ _hdOenv _hdOlib ) ( _tlIannotatedTree,_tlIoriginalTree) = (tl_ _tlOenv _tlOlib ) in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_CaseExpressionList_Nil :: T_CaseExpressionList sem_CaseExpressionList_Nil = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: CaseExpressionList _lhsOoriginalTree :: CaseExpressionList -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 1105 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 1110 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 1115 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 1120 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) -- CaseExpressionListExpressionPair ---------------------------- {- visit 0: inherited attributes: env : Environment lib : LocalIdentifierBindings synthesized attributes: annotatedTree : SELF originalTree : SELF alternatives: alternative Tuple: child x1 : CaseExpressionList child x2 : Expression visit 0: local annotatedTree : _ local originalTree : _ -} type CaseExpressionListExpressionPair = ( (CaseExpressionList),(Expression)) -- cata sem_CaseExpressionListExpressionPair :: CaseExpressionListExpressionPair -> T_CaseExpressionListExpressionPair sem_CaseExpressionListExpressionPair ( x1,x2) = (sem_CaseExpressionListExpressionPair_Tuple (sem_CaseExpressionList x1 ) (sem_Expression x2 ) ) -- semantic domain type T_CaseExpressionListExpressionPair = Environment -> LocalIdentifierBindings -> ( CaseExpressionListExpressionPair,CaseExpressionListExpressionPair) data Inh_CaseExpressionListExpressionPair = Inh_CaseExpressionListExpressionPair {env_Inh_CaseExpressionListExpressionPair :: Environment,lib_Inh_CaseExpressionListExpressionPair :: LocalIdentifierBindings} data Syn_CaseExpressionListExpressionPair = Syn_CaseExpressionListExpressionPair {annotatedTree_Syn_CaseExpressionListExpressionPair :: CaseExpressionListExpressionPair,originalTree_Syn_CaseExpressionListExpressionPair :: CaseExpressionListExpressionPair} wrap_CaseExpressionListExpressionPair :: T_CaseExpressionListExpressionPair -> Inh_CaseExpressionListExpressionPair -> Syn_CaseExpressionListExpressionPair wrap_CaseExpressionListExpressionPair sem (Inh_CaseExpressionListExpressionPair _lhsIenv _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIenv _lhsIlib ) in (Syn_CaseExpressionListExpressionPair _lhsOannotatedTree _lhsOoriginalTree )) sem_CaseExpressionListExpressionPair_Tuple :: T_CaseExpressionList -> T_Expression -> T_CaseExpressionListExpressionPair sem_CaseExpressionListExpressionPair_Tuple x1_ x2_ = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: CaseExpressionListExpressionPair _lhsOoriginalTree :: CaseExpressionListExpressionPair _x1Oenv :: Environment _x1Olib :: LocalIdentifierBindings _x2Oenv :: Environment _x2Olib :: LocalIdentifierBindings _x1IannotatedTree :: CaseExpressionList _x1IoriginalTree :: CaseExpressionList _x2IannotatedTree :: Expression _x2IliftedColumnName :: String _x2IoriginalTree :: Expression -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} (_x1IannotatedTree,_x2IannotatedTree) {-# LINE 1179 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} (_x1IoriginalTree,_x2IoriginalTree) {-# LINE 1184 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 1189 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 1194 "AstInternal.hs" #-} -- copy rule (down) _x1Oenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 1199 "AstInternal.hs" #-} -- copy rule (down) _x1Olib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 1204 "AstInternal.hs" #-} -- copy rule (down) _x2Oenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 1209 "AstInternal.hs" #-} -- copy rule (down) _x2Olib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 1214 "AstInternal.hs" #-} ( _x1IannotatedTree,_x1IoriginalTree) = (x1_ _x1Oenv _x1Olib ) ( _x2IannotatedTree,_x2IliftedColumnName,_x2IoriginalTree) = (x2_ _x2Oenv _x2Olib ) in ( _lhsOannotatedTree,_lhsOoriginalTree))) -- CaseExpressionListExpressionPairList ------------------------ {- visit 0: inherited attributes: env : Environment lib : LocalIdentifierBindings synthesized attributes: annotatedTree : SELF originalTree : SELF alternatives: alternative Cons: child hd : CaseExpressionListExpressionPair child tl : CaseExpressionListExpressionPairList visit 0: local annotatedTree : _ local originalTree : _ alternative Nil: visit 0: local annotatedTree : _ local originalTree : _ -} type CaseExpressionListExpressionPairList = [(CaseExpressionListExpressionPair)] -- cata sem_CaseExpressionListExpressionPairList :: CaseExpressionListExpressionPairList -> T_CaseExpressionListExpressionPairList sem_CaseExpressionListExpressionPairList list = (Prelude.foldr sem_CaseExpressionListExpressionPairList_Cons sem_CaseExpressionListExpressionPairList_Nil (Prelude.map sem_CaseExpressionListExpressionPair list) ) -- semantic domain type T_CaseExpressionListExpressionPairList = Environment -> LocalIdentifierBindings -> ( CaseExpressionListExpressionPairList,CaseExpressionListExpressionPairList) data Inh_CaseExpressionListExpressionPairList = Inh_CaseExpressionListExpressionPairList {env_Inh_CaseExpressionListExpressionPairList :: Environment,lib_Inh_CaseExpressionListExpressionPairList :: LocalIdentifierBindings} data Syn_CaseExpressionListExpressionPairList = Syn_CaseExpressionListExpressionPairList {annotatedTree_Syn_CaseExpressionListExpressionPairList :: CaseExpressionListExpressionPairList,originalTree_Syn_CaseExpressionListExpressionPairList :: CaseExpressionListExpressionPairList} wrap_CaseExpressionListExpressionPairList :: T_CaseExpressionListExpressionPairList -> Inh_CaseExpressionListExpressionPairList -> Syn_CaseExpressionListExpressionPairList wrap_CaseExpressionListExpressionPairList sem (Inh_CaseExpressionListExpressionPairList _lhsIenv _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIenv _lhsIlib ) in (Syn_CaseExpressionListExpressionPairList _lhsOannotatedTree _lhsOoriginalTree )) sem_CaseExpressionListExpressionPairList_Cons :: T_CaseExpressionListExpressionPair -> T_CaseExpressionListExpressionPairList -> T_CaseExpressionListExpressionPairList sem_CaseExpressionListExpressionPairList_Cons hd_ tl_ = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: CaseExpressionListExpressionPairList _lhsOoriginalTree :: CaseExpressionListExpressionPairList _hdOenv :: Environment _hdOlib :: LocalIdentifierBindings _tlOenv :: Environment _tlOlib :: LocalIdentifierBindings _hdIannotatedTree :: CaseExpressionListExpressionPair _hdIoriginalTree :: CaseExpressionListExpressionPair _tlIannotatedTree :: CaseExpressionListExpressionPairList _tlIoriginalTree :: CaseExpressionListExpressionPairList -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} (:) _hdIannotatedTree _tlIannotatedTree {-# LINE 1280 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} (:) _hdIoriginalTree _tlIoriginalTree {-# LINE 1285 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 1290 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 1295 "AstInternal.hs" #-} -- copy rule (down) _hdOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 1300 "AstInternal.hs" #-} -- copy rule (down) _hdOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 1305 "AstInternal.hs" #-} -- copy rule (down) _tlOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 1310 "AstInternal.hs" #-} -- copy rule (down) _tlOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 1315 "AstInternal.hs" #-} ( _hdIannotatedTree,_hdIoriginalTree) = (hd_ _hdOenv _hdOlib ) ( _tlIannotatedTree,_tlIoriginalTree) = (tl_ _tlOenv _tlOlib ) in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_CaseExpressionListExpressionPairList_Nil :: T_CaseExpressionListExpressionPairList sem_CaseExpressionListExpressionPairList_Nil = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: CaseExpressionListExpressionPairList _lhsOoriginalTree :: CaseExpressionListExpressionPairList -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 1331 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 1336 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 1341 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 1346 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) -- CombineType ------------------------------------------------- {- visit 0: inherited attributes: env : Environment lib : LocalIdentifierBindings synthesized attributes: annotatedTree : SELF originalTree : SELF alternatives: alternative Except: visit 0: local annotatedTree : _ local originalTree : _ alternative Intersect: visit 0: local annotatedTree : _ local originalTree : _ alternative Union: visit 0: local annotatedTree : _ local originalTree : _ alternative UnionAll: visit 0: local annotatedTree : _ local originalTree : _ -} data CombineType = Except | Intersect | Union | UnionAll deriving ( Data,Eq,Show,Typeable) -- cata sem_CombineType :: CombineType -> T_CombineType sem_CombineType (Except ) = (sem_CombineType_Except ) sem_CombineType (Intersect ) = (sem_CombineType_Intersect ) sem_CombineType (Union ) = (sem_CombineType_Union ) sem_CombineType (UnionAll ) = (sem_CombineType_UnionAll ) -- semantic domain type T_CombineType = Environment -> LocalIdentifierBindings -> ( CombineType,CombineType) data Inh_CombineType = Inh_CombineType {env_Inh_CombineType :: Environment,lib_Inh_CombineType :: LocalIdentifierBindings} data Syn_CombineType = Syn_CombineType {annotatedTree_Syn_CombineType :: CombineType,originalTree_Syn_CombineType :: CombineType} wrap_CombineType :: T_CombineType -> Inh_CombineType -> Syn_CombineType wrap_CombineType sem (Inh_CombineType _lhsIenv _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIenv _lhsIlib ) in (Syn_CombineType _lhsOannotatedTree _lhsOoriginalTree )) sem_CombineType_Except :: T_CombineType sem_CombineType_Except = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: CombineType _lhsOoriginalTree :: CombineType -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Except {-# LINE 1414 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Except {-# LINE 1419 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 1424 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 1429 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_CombineType_Intersect :: T_CombineType sem_CombineType_Intersect = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: CombineType _lhsOoriginalTree :: CombineType -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Intersect {-# LINE 1441 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Intersect {-# LINE 1446 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 1451 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 1456 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_CombineType_Union :: T_CombineType sem_CombineType_Union = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: CombineType _lhsOoriginalTree :: CombineType -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Union {-# LINE 1468 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Union {-# LINE 1473 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 1478 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 1483 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_CombineType_UnionAll :: T_CombineType sem_CombineType_UnionAll = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: CombineType _lhsOoriginalTree :: CombineType -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} UnionAll {-# LINE 1495 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} UnionAll {-# LINE 1500 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 1505 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 1510 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) -- Constraint -------------------------------------------------- {- visit 0: inherited attributes: env : Environment lib : LocalIdentifierBindings synthesized attributes: annotatedTree : SELF originalTree : SELF alternatives: alternative CheckConstraint: child ann : {Annotation} child name : {String} child expression : Expression visit 0: local annotatedTree : _ local originalTree : _ alternative PrimaryKeyConstraint: child ann : {Annotation} child name : {String} child stringList : StringList visit 0: local annotatedTree : _ local originalTree : _ alternative ReferenceConstraint: child ann : {Annotation} child name : {String} child atts : StringList child table : {String} child tableAtts : StringList child onUpdate : Cascade child onDelete : Cascade visit 0: local annotatedTree : _ local originalTree : _ alternative UniqueConstraint: child ann : {Annotation} child name : {String} child stringList : StringList visit 0: local annotatedTree : _ local originalTree : _ -} data Constraint = CheckConstraint (Annotation) (String) (Expression) | PrimaryKeyConstraint (Annotation) (String) (StringList) | ReferenceConstraint (Annotation) (String) (StringList) (String) (StringList) (Cascade) (Cascade) | UniqueConstraint (Annotation) (String) (StringList) deriving ( Data,Eq,Show,Typeable) -- cata sem_Constraint :: Constraint -> T_Constraint sem_Constraint (CheckConstraint _ann _name _expression ) = (sem_Constraint_CheckConstraint _ann _name (sem_Expression _expression ) ) sem_Constraint (PrimaryKeyConstraint _ann _name _stringList ) = (sem_Constraint_PrimaryKeyConstraint _ann _name (sem_StringList _stringList ) ) sem_Constraint (ReferenceConstraint _ann _name _atts _table _tableAtts _onUpdate _onDelete ) = (sem_Constraint_ReferenceConstraint _ann _name (sem_StringList _atts ) _table (sem_StringList _tableAtts ) (sem_Cascade _onUpdate ) (sem_Cascade _onDelete ) ) sem_Constraint (UniqueConstraint _ann _name _stringList ) = (sem_Constraint_UniqueConstraint _ann _name (sem_StringList _stringList ) ) -- semantic domain type T_Constraint = Environment -> LocalIdentifierBindings -> ( Constraint,Constraint) data Inh_Constraint = Inh_Constraint {env_Inh_Constraint :: Environment,lib_Inh_Constraint :: LocalIdentifierBindings} data Syn_Constraint = Syn_Constraint {annotatedTree_Syn_Constraint :: Constraint,originalTree_Syn_Constraint :: Constraint} wrap_Constraint :: T_Constraint -> Inh_Constraint -> Syn_Constraint wrap_Constraint sem (Inh_Constraint _lhsIenv _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIenv _lhsIlib ) in (Syn_Constraint _lhsOannotatedTree _lhsOoriginalTree )) sem_Constraint_CheckConstraint :: Annotation -> String -> T_Expression -> T_Constraint sem_Constraint_CheckConstraint ann_ name_ expression_ = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: Constraint _lhsOoriginalTree :: Constraint _expressionOenv :: Environment _expressionOlib :: LocalIdentifierBindings _expressionIannotatedTree :: Expression _expressionIliftedColumnName :: String _expressionIoriginalTree :: Expression -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} CheckConstraint ann_ name_ _expressionIannotatedTree {-# LINE 1602 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} CheckConstraint ann_ name_ _expressionIoriginalTree {-# LINE 1607 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 1612 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 1617 "AstInternal.hs" #-} -- copy rule (down) _expressionOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 1622 "AstInternal.hs" #-} -- copy rule (down) _expressionOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 1627 "AstInternal.hs" #-} ( _expressionIannotatedTree,_expressionIliftedColumnName,_expressionIoriginalTree) = (expression_ _expressionOenv _expressionOlib ) in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_Constraint_PrimaryKeyConstraint :: Annotation -> String -> T_StringList -> T_Constraint sem_Constraint_PrimaryKeyConstraint ann_ name_ stringList_ = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: Constraint _lhsOoriginalTree :: Constraint _stringListOenv :: Environment _stringListOlib :: LocalIdentifierBindings _stringListIannotatedTree :: StringList _stringListIoriginalTree :: StringList _stringListIstrings :: ([String]) -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} PrimaryKeyConstraint ann_ name_ _stringListIannotatedTree {-# LINE 1649 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} PrimaryKeyConstraint ann_ name_ _stringListIoriginalTree {-# LINE 1654 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 1659 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 1664 "AstInternal.hs" #-} -- copy rule (down) _stringListOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 1669 "AstInternal.hs" #-} -- copy rule (down) _stringListOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 1674 "AstInternal.hs" #-} ( _stringListIannotatedTree,_stringListIoriginalTree,_stringListIstrings) = (stringList_ _stringListOenv _stringListOlib ) in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_Constraint_ReferenceConstraint :: Annotation -> String -> T_StringList -> String -> T_StringList -> T_Cascade -> T_Cascade -> T_Constraint sem_Constraint_ReferenceConstraint ann_ name_ atts_ table_ tableAtts_ onUpdate_ onDelete_ = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: Constraint _lhsOoriginalTree :: Constraint _attsOenv :: Environment _attsOlib :: LocalIdentifierBindings _tableAttsOenv :: Environment _tableAttsOlib :: LocalIdentifierBindings _onUpdateOenv :: Environment _onUpdateOlib :: LocalIdentifierBindings _onDeleteOenv :: Environment _onDeleteOlib :: LocalIdentifierBindings _attsIannotatedTree :: StringList _attsIoriginalTree :: StringList _attsIstrings :: ([String]) _tableAttsIannotatedTree :: StringList _tableAttsIoriginalTree :: StringList _tableAttsIstrings :: ([String]) _onUpdateIannotatedTree :: Cascade _onUpdateIoriginalTree :: Cascade _onDeleteIannotatedTree :: Cascade _onDeleteIoriginalTree :: Cascade -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} ReferenceConstraint ann_ name_ _attsIannotatedTree table_ _tableAttsIannotatedTree _onUpdateIannotatedTree _onDeleteIannotatedTree {-# LINE 1713 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} ReferenceConstraint ann_ name_ _attsIoriginalTree table_ _tableAttsIoriginalTree _onUpdateIoriginalTree _onDeleteIoriginalTree {-# LINE 1718 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 1723 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 1728 "AstInternal.hs" #-} -- copy rule (down) _attsOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 1733 "AstInternal.hs" #-} -- copy rule (down) _attsOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 1738 "AstInternal.hs" #-} -- copy rule (down) _tableAttsOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 1743 "AstInternal.hs" #-} -- copy rule (down) _tableAttsOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 1748 "AstInternal.hs" #-} -- copy rule (down) _onUpdateOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 1753 "AstInternal.hs" #-} -- copy rule (down) _onUpdateOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 1758 "AstInternal.hs" #-} -- copy rule (down) _onDeleteOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 1763 "AstInternal.hs" #-} -- copy rule (down) _onDeleteOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 1768 "AstInternal.hs" #-} ( _attsIannotatedTree,_attsIoriginalTree,_attsIstrings) = (atts_ _attsOenv _attsOlib ) ( _tableAttsIannotatedTree,_tableAttsIoriginalTree,_tableAttsIstrings) = (tableAtts_ _tableAttsOenv _tableAttsOlib ) ( _onUpdateIannotatedTree,_onUpdateIoriginalTree) = (onUpdate_ _onUpdateOenv _onUpdateOlib ) ( _onDeleteIannotatedTree,_onDeleteIoriginalTree) = (onDelete_ _onDeleteOenv _onDeleteOlib ) in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_Constraint_UniqueConstraint :: Annotation -> String -> T_StringList -> T_Constraint sem_Constraint_UniqueConstraint ann_ name_ stringList_ = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: Constraint _lhsOoriginalTree :: Constraint _stringListOenv :: Environment _stringListOlib :: LocalIdentifierBindings _stringListIannotatedTree :: StringList _stringListIoriginalTree :: StringList _stringListIstrings :: ([String]) -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} UniqueConstraint ann_ name_ _stringListIannotatedTree {-# LINE 1796 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} UniqueConstraint ann_ name_ _stringListIoriginalTree {-# LINE 1801 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 1806 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 1811 "AstInternal.hs" #-} -- copy rule (down) _stringListOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 1816 "AstInternal.hs" #-} -- copy rule (down) _stringListOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 1821 "AstInternal.hs" #-} ( _stringListIannotatedTree,_stringListIoriginalTree,_stringListIstrings) = (stringList_ _stringListOenv _stringListOlib ) in ( _lhsOannotatedTree,_lhsOoriginalTree))) -- ConstraintList ---------------------------------------------- {- visit 0: inherited attributes: env : Environment lib : LocalIdentifierBindings synthesized attributes: annotatedTree : SELF originalTree : SELF alternatives: alternative Cons: child hd : Constraint child tl : ConstraintList visit 0: local annotatedTree : _ local originalTree : _ alternative Nil: visit 0: local annotatedTree : _ local originalTree : _ -} type ConstraintList = [(Constraint)] -- cata sem_ConstraintList :: ConstraintList -> T_ConstraintList sem_ConstraintList list = (Prelude.foldr sem_ConstraintList_Cons sem_ConstraintList_Nil (Prelude.map sem_Constraint list) ) -- semantic domain type T_ConstraintList = Environment -> LocalIdentifierBindings -> ( ConstraintList,ConstraintList) data Inh_ConstraintList = Inh_ConstraintList {env_Inh_ConstraintList :: Environment,lib_Inh_ConstraintList :: LocalIdentifierBindings} data Syn_ConstraintList = Syn_ConstraintList {annotatedTree_Syn_ConstraintList :: ConstraintList,originalTree_Syn_ConstraintList :: ConstraintList} wrap_ConstraintList :: T_ConstraintList -> Inh_ConstraintList -> Syn_ConstraintList wrap_ConstraintList sem (Inh_ConstraintList _lhsIenv _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIenv _lhsIlib ) in (Syn_ConstraintList _lhsOannotatedTree _lhsOoriginalTree )) sem_ConstraintList_Cons :: T_Constraint -> T_ConstraintList -> T_ConstraintList sem_ConstraintList_Cons hd_ tl_ = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: ConstraintList _lhsOoriginalTree :: ConstraintList _hdOenv :: Environment _hdOlib :: LocalIdentifierBindings _tlOenv :: Environment _tlOlib :: LocalIdentifierBindings _hdIannotatedTree :: Constraint _hdIoriginalTree :: Constraint _tlIannotatedTree :: ConstraintList _tlIoriginalTree :: ConstraintList -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} (:) _hdIannotatedTree _tlIannotatedTree {-# LINE 1885 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} (:) _hdIoriginalTree _tlIoriginalTree {-# LINE 1890 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 1895 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 1900 "AstInternal.hs" #-} -- copy rule (down) _hdOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 1905 "AstInternal.hs" #-} -- copy rule (down) _hdOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 1910 "AstInternal.hs" #-} -- copy rule (down) _tlOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 1915 "AstInternal.hs" #-} -- copy rule (down) _tlOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 1920 "AstInternal.hs" #-} ( _hdIannotatedTree,_hdIoriginalTree) = (hd_ _hdOenv _hdOlib ) ( _tlIannotatedTree,_tlIoriginalTree) = (tl_ _tlOenv _tlOlib ) in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_ConstraintList_Nil :: T_ConstraintList sem_ConstraintList_Nil = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: ConstraintList _lhsOoriginalTree :: ConstraintList -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 1936 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 1941 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 1946 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 1951 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) -- CopySource -------------------------------------------------- {- visit 0: inherited attributes: env : Environment lib : LocalIdentifierBindings synthesized attributes: annotatedTree : SELF originalTree : SELF alternatives: alternative CopyFilename: child string : {String} visit 0: local annotatedTree : _ local originalTree : _ alternative Stdin: visit 0: local annotatedTree : _ local originalTree : _ -} data CopySource = CopyFilename (String) | Stdin deriving ( Data,Eq,Show,Typeable) -- cata sem_CopySource :: CopySource -> T_CopySource sem_CopySource (CopyFilename _string ) = (sem_CopySource_CopyFilename _string ) sem_CopySource (Stdin ) = (sem_CopySource_Stdin ) -- semantic domain type T_CopySource = Environment -> LocalIdentifierBindings -> ( CopySource,CopySource) data Inh_CopySource = Inh_CopySource {env_Inh_CopySource :: Environment,lib_Inh_CopySource :: LocalIdentifierBindings} data Syn_CopySource = Syn_CopySource {annotatedTree_Syn_CopySource :: CopySource,originalTree_Syn_CopySource :: CopySource} wrap_CopySource :: T_CopySource -> Inh_CopySource -> Syn_CopySource wrap_CopySource sem (Inh_CopySource _lhsIenv _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIenv _lhsIlib ) in (Syn_CopySource _lhsOannotatedTree _lhsOoriginalTree )) sem_CopySource_CopyFilename :: String -> T_CopySource sem_CopySource_CopyFilename string_ = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: CopySource _lhsOoriginalTree :: CopySource -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} CopyFilename string_ {-# LINE 2007 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} CopyFilename string_ {-# LINE 2012 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 2017 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 2022 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_CopySource_Stdin :: T_CopySource sem_CopySource_Stdin = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: CopySource _lhsOoriginalTree :: CopySource -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Stdin {-# LINE 2034 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Stdin {-# LINE 2039 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 2044 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 2049 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) -- Direction --------------------------------------------------- {- visit 0: inherited attributes: env : Environment lib : LocalIdentifierBindings synthesized attributes: annotatedTree : SELF originalTree : SELF alternatives: alternative Asc: visit 0: local annotatedTree : _ local originalTree : _ alternative Desc: visit 0: local annotatedTree : _ local originalTree : _ -} data Direction = Asc | Desc deriving ( Data,Eq,Show,Typeable) -- cata sem_Direction :: Direction -> T_Direction sem_Direction (Asc ) = (sem_Direction_Asc ) sem_Direction (Desc ) = (sem_Direction_Desc ) -- semantic domain type T_Direction = Environment -> LocalIdentifierBindings -> ( Direction,Direction) data Inh_Direction = Inh_Direction {env_Inh_Direction :: Environment,lib_Inh_Direction :: LocalIdentifierBindings} data Syn_Direction = Syn_Direction {annotatedTree_Syn_Direction :: Direction,originalTree_Syn_Direction :: Direction} wrap_Direction :: T_Direction -> Inh_Direction -> Syn_Direction wrap_Direction sem (Inh_Direction _lhsIenv _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIenv _lhsIlib ) in (Syn_Direction _lhsOannotatedTree _lhsOoriginalTree )) sem_Direction_Asc :: T_Direction sem_Direction_Asc = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: Direction _lhsOoriginalTree :: Direction -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Asc {-# LINE 2103 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Asc {-# LINE 2108 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 2113 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 2118 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_Direction_Desc :: T_Direction sem_Direction_Desc = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: Direction _lhsOoriginalTree :: Direction -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Desc {-# LINE 2130 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Desc {-# LINE 2135 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 2140 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 2145 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) -- Distinct ---------------------------------------------------- {- visit 0: inherited attributes: env : Environment lib : LocalIdentifierBindings synthesized attributes: annotatedTree : SELF originalTree : SELF alternatives: alternative Distinct: visit 0: local annotatedTree : _ local originalTree : _ alternative Dupes: visit 0: local annotatedTree : _ local originalTree : _ -} data Distinct = Distinct | Dupes deriving ( Data,Eq,Show,Typeable) -- cata sem_Distinct :: Distinct -> T_Distinct sem_Distinct (Distinct ) = (sem_Distinct_Distinct ) sem_Distinct (Dupes ) = (sem_Distinct_Dupes ) -- semantic domain type T_Distinct = Environment -> LocalIdentifierBindings -> ( Distinct,Distinct) data Inh_Distinct = Inh_Distinct {env_Inh_Distinct :: Environment,lib_Inh_Distinct :: LocalIdentifierBindings} data Syn_Distinct = Syn_Distinct {annotatedTree_Syn_Distinct :: Distinct,originalTree_Syn_Distinct :: Distinct} wrap_Distinct :: T_Distinct -> Inh_Distinct -> Syn_Distinct wrap_Distinct sem (Inh_Distinct _lhsIenv _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIenv _lhsIlib ) in (Syn_Distinct _lhsOannotatedTree _lhsOoriginalTree )) sem_Distinct_Distinct :: T_Distinct sem_Distinct_Distinct = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: Distinct _lhsOoriginalTree :: Distinct -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Distinct {-# LINE 2199 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Distinct {-# LINE 2204 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 2209 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 2214 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_Distinct_Dupes :: T_Distinct sem_Distinct_Dupes = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: Distinct _lhsOoriginalTree :: Distinct -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Dupes {-# LINE 2226 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Dupes {-# LINE 2231 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 2236 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 2241 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) -- DropType ---------------------------------------------------- {- visit 0: inherited attributes: env : Environment lib : LocalIdentifierBindings synthesized attributes: annotatedTree : SELF originalTree : SELF alternatives: alternative Domain: visit 0: local annotatedTree : _ local originalTree : _ alternative Table: visit 0: local annotatedTree : _ local originalTree : _ alternative Type: visit 0: local annotatedTree : _ local originalTree : _ alternative View: visit 0: local annotatedTree : _ local originalTree : _ -} data DropType = Domain | Table | Type | View deriving ( Data,Eq,Show,Typeable) -- cata sem_DropType :: DropType -> T_DropType sem_DropType (Domain ) = (sem_DropType_Domain ) sem_DropType (Table ) = (sem_DropType_Table ) sem_DropType (Type ) = (sem_DropType_Type ) sem_DropType (View ) = (sem_DropType_View ) -- semantic domain type T_DropType = Environment -> LocalIdentifierBindings -> ( DropType,DropType) data Inh_DropType = Inh_DropType {env_Inh_DropType :: Environment,lib_Inh_DropType :: LocalIdentifierBindings} data Syn_DropType = Syn_DropType {annotatedTree_Syn_DropType :: DropType,originalTree_Syn_DropType :: DropType} wrap_DropType :: T_DropType -> Inh_DropType -> Syn_DropType wrap_DropType sem (Inh_DropType _lhsIenv _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIenv _lhsIlib ) in (Syn_DropType _lhsOannotatedTree _lhsOoriginalTree )) sem_DropType_Domain :: T_DropType sem_DropType_Domain = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: DropType _lhsOoriginalTree :: DropType -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Domain {-# LINE 2309 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Domain {-# LINE 2314 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 2319 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 2324 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_DropType_Table :: T_DropType sem_DropType_Table = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: DropType _lhsOoriginalTree :: DropType -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Table {-# LINE 2336 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Table {-# LINE 2341 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 2346 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 2351 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_DropType_Type :: T_DropType sem_DropType_Type = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: DropType _lhsOoriginalTree :: DropType -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Type {-# LINE 2363 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Type {-# LINE 2368 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 2373 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 2378 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_DropType_View :: T_DropType sem_DropType_View = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: DropType _lhsOoriginalTree :: DropType -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} View {-# LINE 2390 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} View {-# LINE 2395 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 2400 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 2405 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) -- Expression -------------------------------------------------- {- visit 0: inherited attributes: env : Environment lib : LocalIdentifierBindings synthesized attributes: annotatedTree : SELF liftedColumnName : String originalTree : SELF alternatives: alternative BooleanLit: child ann : {Annotation} child b : {Bool} visit 0: local tpe : _ local backTree : _ local annotatedTree : _ local originalTree : _ alternative Case: child ann : {Annotation} child cases : CaseExpressionListExpressionPairList child els : MaybeExpression visit 0: local whenTypes : _ local thenTypes : _ local tpe : _ local backTree : _ local annotatedTree : _ local originalTree : _ alternative CaseSimple: child ann : {Annotation} child value : Expression child cases : CaseExpressionListExpressionPairList child els : MaybeExpression visit 0: local whenTypes : _ local thenTypes : _ local tpe : _ local backTree : _ local annotatedTree : _ local originalTree : _ alternative Cast: child ann : {Annotation} child expr : Expression child tn : TypeName visit 0: local tpe : _ local backTree : _ local annotatedTree : _ local originalTree : _ alternative Exists: child ann : {Annotation} child sel : SelectExpression visit 0: local tpe : _ local backTree : _ local annotatedTree : _ local originalTree : _ alternative FloatLit: child ann : {Annotation} child d : {Double} visit 0: local tpe : _ local backTree : _ local annotatedTree : _ local originalTree : _ alternative FunCall: child ann : {Annotation} child funName : {String} child args : ExpressionList visit 0: local tpe : _ local backTree : _ local annotatedTree : _ local originalTree : _ alternative Identifier: child ann : {Annotation} child i : {String} visit 0: local tpe : _ local backTree : _ local annotatedTree : _ local originalTree : _ alternative InPredicate: child ann : {Annotation} child expr : Expression child i : {Bool} child list : InList visit 0: local tpe : _ local backTree : _ local annotatedTree : _ local originalTree : _ alternative IntegerLit: child ann : {Annotation} child i : {Integer} visit 0: local tpe : _ local backTree : _ local annotatedTree : _ local originalTree : _ alternative LiftOperator: child ann : {Annotation} child oper : {String} child flav : LiftFlavour child args : ExpressionList visit 0: local tpe : _ local backTree : _ local annotatedTree : _ local originalTree : _ alternative NullLit: child ann : {Annotation} visit 0: local tpe : _ local backTree : _ local annotatedTree : _ local originalTree : _ alternative Placeholder: child ann : {Annotation} visit 0: local tpe : _ local backTree : _ local annotatedTree : _ local originalTree : _ alternative PositionalArg: child ann : {Annotation} child p : {Integer} visit 0: local tpe : _ local backTree : _ local annotatedTree : _ local originalTree : _ alternative ScalarSubQuery: child ann : {Annotation} child sel : SelectExpression visit 0: local tpe : _ local backTree : _ local annotatedTree : _ local originalTree : _ alternative StringLit: child ann : {Annotation} child quote : {String} child value : {String} visit 0: local tpe : _ local backTree : _ local annotatedTree : _ local originalTree : _ alternative WindowFn: child ann : {Annotation} child fn : Expression child partitionBy : ExpressionList child orderBy : ExpressionList child dir : Direction child frm : FrameClause visit 0: local tpe : _ local backTree : _ local annotatedTree : _ local originalTree : _ -} data Expression = BooleanLit (Annotation) (Bool) | Case (Annotation) (CaseExpressionListExpressionPairList) (MaybeExpression) | CaseSimple (Annotation) (Expression) (CaseExpressionListExpressionPairList) (MaybeExpression) | Cast (Annotation) (Expression) (TypeName) | Exists (Annotation) (SelectExpression) | FloatLit (Annotation) (Double) | FunCall (Annotation) (String) (ExpressionList) | Identifier (Annotation) (String) | InPredicate (Annotation) (Expression) (Bool) (InList) | IntegerLit (Annotation) (Integer) | LiftOperator (Annotation) (String) (LiftFlavour) (ExpressionList) | NullLit (Annotation) | Placeholder (Annotation) | PositionalArg (Annotation) (Integer) | ScalarSubQuery (Annotation) (SelectExpression) | StringLit (Annotation) (String) (String) | WindowFn (Annotation) (Expression) (ExpressionList) (ExpressionList) (Direction) (FrameClause) deriving ( Data,Eq,Show,Typeable) -- cata sem_Expression :: Expression -> T_Expression sem_Expression (BooleanLit _ann _b ) = (sem_Expression_BooleanLit _ann _b ) sem_Expression (Case _ann _cases _els ) = (sem_Expression_Case _ann (sem_CaseExpressionListExpressionPairList _cases ) (sem_MaybeExpression _els ) ) sem_Expression (CaseSimple _ann _value _cases _els ) = (sem_Expression_CaseSimple _ann (sem_Expression _value ) (sem_CaseExpressionListExpressionPairList _cases ) (sem_MaybeExpression _els ) ) sem_Expression (Cast _ann _expr _tn ) = (sem_Expression_Cast _ann (sem_Expression _expr ) (sem_TypeName _tn ) ) sem_Expression (Exists _ann _sel ) = (sem_Expression_Exists _ann (sem_SelectExpression _sel ) ) sem_Expression (FloatLit _ann _d ) = (sem_Expression_FloatLit _ann _d ) sem_Expression (FunCall _ann _funName _args ) = (sem_Expression_FunCall _ann _funName (sem_ExpressionList _args ) ) sem_Expression (Identifier _ann _i ) = (sem_Expression_Identifier _ann _i ) sem_Expression (InPredicate _ann _expr _i _list ) = (sem_Expression_InPredicate _ann (sem_Expression _expr ) _i (sem_InList _list ) ) sem_Expression (IntegerLit _ann _i ) = (sem_Expression_IntegerLit _ann _i ) sem_Expression (LiftOperator _ann _oper _flav _args ) = (sem_Expression_LiftOperator _ann _oper (sem_LiftFlavour _flav ) (sem_ExpressionList _args ) ) sem_Expression (NullLit _ann ) = (sem_Expression_NullLit _ann ) sem_Expression (Placeholder _ann ) = (sem_Expression_Placeholder _ann ) sem_Expression (PositionalArg _ann _p ) = (sem_Expression_PositionalArg _ann _p ) sem_Expression (ScalarSubQuery _ann _sel ) = (sem_Expression_ScalarSubQuery _ann (sem_SelectExpression _sel ) ) sem_Expression (StringLit _ann _quote _value ) = (sem_Expression_StringLit _ann _quote _value ) sem_Expression (WindowFn _ann _fn _partitionBy _orderBy _dir _frm ) = (sem_Expression_WindowFn _ann (sem_Expression _fn ) (sem_ExpressionList _partitionBy ) (sem_ExpressionList _orderBy ) (sem_Direction _dir ) (sem_FrameClause _frm ) ) -- semantic domain type T_Expression = Environment -> LocalIdentifierBindings -> ( Expression,String,Expression) data Inh_Expression = Inh_Expression {env_Inh_Expression :: Environment,lib_Inh_Expression :: LocalIdentifierBindings} data Syn_Expression = Syn_Expression {annotatedTree_Syn_Expression :: Expression,liftedColumnName_Syn_Expression :: String,originalTree_Syn_Expression :: Expression} wrap_Expression :: T_Expression -> Inh_Expression -> Syn_Expression wrap_Expression sem (Inh_Expression _lhsIenv _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOliftedColumnName,_lhsOoriginalTree) = (sem _lhsIenv _lhsIlib ) in (Syn_Expression _lhsOannotatedTree _lhsOliftedColumnName _lhsOoriginalTree )) sem_Expression_BooleanLit :: Annotation -> Bool -> T_Expression sem_Expression_BooleanLit ann_ b_ = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: Expression _lhsOliftedColumnName :: String _lhsOoriginalTree :: Expression -- "./TypeChecking/Expressions.ag"(line 14, column 9) _lhsOannotatedTree = {-# LINE 14 "./TypeChecking/Expressions.ag" #-} annTypesAndErrors _backTree (tpeToT _tpe ) (getErrors _tpe ) Nothing {-# LINE 2655 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 29, column 19) _tpe = {-# LINE 29 "./TypeChecking/Expressions.ag" #-} Right typeBool {-# LINE 2660 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 41, column 9) _backTree = {-# LINE 41 "./TypeChecking/Expressions.ag" #-} BooleanLit ann_ b_ {-# LINE 2665 "AstInternal.hs" #-} -- "./TypeChecking/SelectLists.ag"(line 177, column 7) _lhsOliftedColumnName = {-# LINE 177 "./TypeChecking/SelectLists.ag" #-} "" {-# LINE 2670 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} BooleanLit ann_ b_ {-# LINE 2675 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} BooleanLit ann_ b_ {-# LINE 2680 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 2685 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOliftedColumnName,_lhsOoriginalTree))) sem_Expression_Case :: Annotation -> T_CaseExpressionListExpressionPairList -> T_MaybeExpression -> T_Expression sem_Expression_Case ann_ cases_ els_ = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: Expression _lhsOliftedColumnName :: String _lhsOoriginalTree :: Expression _casesOenv :: Environment _casesOlib :: LocalIdentifierBindings _elsOenv :: Environment _elsOlib :: LocalIdentifierBindings _casesIannotatedTree :: CaseExpressionListExpressionPairList _casesIoriginalTree :: CaseExpressionListExpressionPairList _elsIannotatedTree :: MaybeExpression _elsIoriginalTree :: MaybeExpression -- "./TypeChecking/Expressions.ag"(line 14, column 9) _lhsOannotatedTree = {-# LINE 14 "./TypeChecking/Expressions.ag" #-} annTypesAndErrors _backTree (tpeToT _tpe ) (getErrors _tpe ) Nothing {-# LINE 2712 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 196, column 9) _whenTypes = {-# LINE 196 "./TypeChecking/Expressions.ag" #-} map getTypeAnnotation $ concatMap fst $ _casesIannotatedTree {-# LINE 2718 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 198, column 9) _thenTypes = {-# LINE 198 "./TypeChecking/Expressions.ag" #-} map getTypeAnnotation $ (map snd $ _casesIannotatedTree) ++ maybeToList _elsIannotatedTree {-# LINE 2725 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 204, column 9) _tpe = {-# LINE 204 "./TypeChecking/Expressions.ag" #-} dependsOnRTpe _whenTypes $ do errorWhen (any (/= typeBool) _whenTypes ) $ [WrongTypes typeBool _whenTypes ] dependsOnRTpe _thenTypes $ resolveResultSetType _lhsIenv _thenTypes {-# LINE 2734 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 210, column 9) _backTree = {-# LINE 210 "./TypeChecking/Expressions.ag" #-} Case ann_ _casesIannotatedTree _elsIannotatedTree {-# LINE 2739 "AstInternal.hs" #-} -- "./TypeChecking/SelectLists.ag"(line 177, column 7) _lhsOliftedColumnName = {-# LINE 177 "./TypeChecking/SelectLists.ag" #-} "" {-# LINE 2744 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Case ann_ _casesIannotatedTree _elsIannotatedTree {-# LINE 2749 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Case ann_ _casesIoriginalTree _elsIoriginalTree {-# LINE 2754 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 2759 "AstInternal.hs" #-} -- copy rule (down) _casesOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 2764 "AstInternal.hs" #-} -- copy rule (down) _casesOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 2769 "AstInternal.hs" #-} -- copy rule (down) _elsOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 2774 "AstInternal.hs" #-} -- copy rule (down) _elsOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 2779 "AstInternal.hs" #-} ( _casesIannotatedTree,_casesIoriginalTree) = (cases_ _casesOenv _casesOlib ) ( _elsIannotatedTree,_elsIoriginalTree) = (els_ _elsOenv _elsOlib ) in ( _lhsOannotatedTree,_lhsOliftedColumnName,_lhsOoriginalTree))) sem_Expression_CaseSimple :: Annotation -> T_Expression -> T_CaseExpressionListExpressionPairList -> T_MaybeExpression -> T_Expression sem_Expression_CaseSimple ann_ value_ cases_ els_ = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: Expression _lhsOoriginalTree :: Expression _lhsOliftedColumnName :: String _valueOenv :: Environment _valueOlib :: LocalIdentifierBindings _casesOenv :: Environment _casesOlib :: LocalIdentifierBindings _elsOenv :: Environment _elsOlib :: LocalIdentifierBindings _valueIannotatedTree :: Expression _valueIliftedColumnName :: String _valueIoriginalTree :: Expression _casesIannotatedTree :: CaseExpressionListExpressionPairList _casesIoriginalTree :: CaseExpressionListExpressionPairList _elsIannotatedTree :: MaybeExpression _elsIoriginalTree :: MaybeExpression -- "./TypeChecking/Expressions.ag"(line 14, column 9) _lhsOannotatedTree = {-# LINE 14 "./TypeChecking/Expressions.ag" #-} annTypesAndErrors _backTree (tpeToT _tpe ) (getErrors _tpe ) Nothing {-# LINE 2816 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 196, column 9) _whenTypes = {-# LINE 196 "./TypeChecking/Expressions.ag" #-} map getTypeAnnotation $ concatMap fst $ _casesIannotatedTree {-# LINE 2822 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 198, column 9) _thenTypes = {-# LINE 198 "./TypeChecking/Expressions.ag" #-} map getTypeAnnotation $ (map snd $ _casesIannotatedTree) ++ maybeToList _elsIannotatedTree {-# LINE 2829 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 215, column 9) _tpe = {-# LINE 215 "./TypeChecking/Expressions.ag" #-} dependsOnRTpe _whenTypes $ do let valueType = getTypeAnnotation _valueIannotatedTree checkWhenTypes <- resolveResultSetType _lhsIenv (valueType : _whenTypes ) dependsOnRTpe _thenTypes $ resolveResultSetType _lhsIenv _thenTypes {-# LINE 2839 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 222, column 9) _backTree = {-# LINE 222 "./TypeChecking/Expressions.ag" #-} CaseSimple ann_ _valueIannotatedTree _casesIannotatedTree _elsIannotatedTree {-# LINE 2847 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} CaseSimple ann_ _valueIannotatedTree _casesIannotatedTree _elsIannotatedTree {-# LINE 2852 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} CaseSimple ann_ _valueIoriginalTree _casesIoriginalTree _elsIoriginalTree {-# LINE 2857 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 2862 "AstInternal.hs" #-} -- copy rule (up) _lhsOliftedColumnName = {-# LINE 161 "./TypeChecking/SelectLists.ag" #-} _valueIliftedColumnName {-# LINE 2867 "AstInternal.hs" #-} -- copy rule (down) _valueOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 2872 "AstInternal.hs" #-} -- copy rule (down) _valueOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 2877 "AstInternal.hs" #-} -- copy rule (down) _casesOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 2882 "AstInternal.hs" #-} -- copy rule (down) _casesOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 2887 "AstInternal.hs" #-} -- copy rule (down) _elsOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 2892 "AstInternal.hs" #-} -- copy rule (down) _elsOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 2897 "AstInternal.hs" #-} ( _valueIannotatedTree,_valueIliftedColumnName,_valueIoriginalTree) = (value_ _valueOenv _valueOlib ) ( _casesIannotatedTree,_casesIoriginalTree) = (cases_ _casesOenv _casesOlib ) ( _elsIannotatedTree,_elsIoriginalTree) = (els_ _elsOenv _elsOlib ) in ( _lhsOannotatedTree,_lhsOliftedColumnName,_lhsOoriginalTree))) sem_Expression_Cast :: Annotation -> T_Expression -> T_TypeName -> T_Expression sem_Expression_Cast ann_ expr_ tn_ = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: Expression _lhsOliftedColumnName :: String _lhsOoriginalTree :: Expression _exprOenv :: Environment _exprOlib :: LocalIdentifierBindings _tnOenv :: Environment _tnOlib :: LocalIdentifierBindings _exprIannotatedTree :: Expression _exprIliftedColumnName :: String _exprIoriginalTree :: Expression _tnIannotatedTree :: TypeName _tnInamedType :: Type _tnIoriginalTree :: TypeName -- "./TypeChecking/Expressions.ag"(line 14, column 9) _lhsOannotatedTree = {-# LINE 14 "./TypeChecking/Expressions.ag" #-} annTypesAndErrors _backTree (tpeToT _tpe ) (getErrors _tpe ) Nothing {-# LINE 2932 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 54, column 12) _tpe = {-# LINE 54 "./TypeChecking/Expressions.ag" #-} Right $ _tnInamedType {-# LINE 2937 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 55, column 12) _backTree = {-# LINE 55 "./TypeChecking/Expressions.ag" #-} Cast ann_ _exprIannotatedTree _tnIannotatedTree {-# LINE 2942 "AstInternal.hs" #-} -- "./TypeChecking/SelectLists.ag"(line 169, column 10) _lhsOliftedColumnName = {-# LINE 169 "./TypeChecking/SelectLists.ag" #-} case _tnIannotatedTree of SimpleTypeName _ tn -> tn _ -> "" {-# LINE 2949 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Cast ann_ _exprIannotatedTree _tnIannotatedTree {-# LINE 2954 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Cast ann_ _exprIoriginalTree _tnIoriginalTree {-# LINE 2959 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 2964 "AstInternal.hs" #-} -- copy rule (down) _exprOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 2969 "AstInternal.hs" #-} -- copy rule (down) _exprOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 2974 "AstInternal.hs" #-} -- copy rule (down) _tnOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 2979 "AstInternal.hs" #-} -- copy rule (down) _tnOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 2984 "AstInternal.hs" #-} ( _exprIannotatedTree,_exprIliftedColumnName,_exprIoriginalTree) = (expr_ _exprOenv _exprOlib ) ( _tnIannotatedTree,_tnInamedType,_tnIoriginalTree) = (tn_ _tnOenv _tnOlib ) in ( _lhsOannotatedTree,_lhsOliftedColumnName,_lhsOoriginalTree))) sem_Expression_Exists :: Annotation -> T_SelectExpression -> T_Expression sem_Expression_Exists ann_ sel_ = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: Expression _lhsOliftedColumnName :: String _lhsOoriginalTree :: Expression _selOenv :: Environment _selOlib :: LocalIdentifierBindings _selIannotatedTree :: SelectExpression _selIlibUpdates :: ([LocalIdentifierBindingsUpdate]) _selIoriginalTree :: SelectExpression -- "./TypeChecking/Expressions.ag"(line 14, column 9) _lhsOannotatedTree = {-# LINE 14 "./TypeChecking/Expressions.ag" #-} annTypesAndErrors _backTree (tpeToT _tpe ) (getErrors _tpe ) Nothing {-# LINE 3011 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 253, column 9) _tpe = {-# LINE 253 "./TypeChecking/Expressions.ag" #-} Right typeBool {-# LINE 3016 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 254, column 9) _backTree = {-# LINE 254 "./TypeChecking/Expressions.ag" #-} Exists ann_ _selIannotatedTree {-# LINE 3021 "AstInternal.hs" #-} -- "./TypeChecking/SelectLists.ag"(line 177, column 7) _lhsOliftedColumnName = {-# LINE 177 "./TypeChecking/SelectLists.ag" #-} "" {-# LINE 3026 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Exists ann_ _selIannotatedTree {-# LINE 3031 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Exists ann_ _selIoriginalTree {-# LINE 3036 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 3041 "AstInternal.hs" #-} -- copy rule (down) _selOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 3046 "AstInternal.hs" #-} -- copy rule (down) _selOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 3051 "AstInternal.hs" #-} ( _selIannotatedTree,_selIlibUpdates,_selIoriginalTree) = (sel_ _selOenv _selOlib ) in ( _lhsOannotatedTree,_lhsOliftedColumnName,_lhsOoriginalTree))) sem_Expression_FloatLit :: Annotation -> Double -> T_Expression sem_Expression_FloatLit ann_ d_ = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: Expression _lhsOliftedColumnName :: String _lhsOoriginalTree :: Expression -- "./TypeChecking/Expressions.ag"(line 14, column 9) _lhsOannotatedTree = {-# LINE 14 "./TypeChecking/Expressions.ag" #-} annTypesAndErrors _backTree (tpeToT _tpe ) (getErrors _tpe ) Nothing {-# LINE 3071 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 28, column 17) _tpe = {-# LINE 28 "./TypeChecking/Expressions.ag" #-} Right typeNumeric {-# LINE 3076 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 39, column 9) _backTree = {-# LINE 39 "./TypeChecking/Expressions.ag" #-} FloatLit ann_ d_ {-# LINE 3081 "AstInternal.hs" #-} -- "./TypeChecking/SelectLists.ag"(line 177, column 7) _lhsOliftedColumnName = {-# LINE 177 "./TypeChecking/SelectLists.ag" #-} "" {-# LINE 3086 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} FloatLit ann_ d_ {-# LINE 3091 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} FloatLit ann_ d_ {-# LINE 3096 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 3101 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOliftedColumnName,_lhsOoriginalTree))) sem_Expression_FunCall :: Annotation -> String -> T_ExpressionList -> T_Expression sem_Expression_FunCall ann_ funName_ args_ = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: Expression _lhsOliftedColumnName :: String _lhsOoriginalTree :: Expression _argsOenv :: Environment _argsOlib :: LocalIdentifierBindings _argsIannotatedTree :: ExpressionList _argsIoriginalTree :: ExpressionList _argsItypeList :: ([Type]) -- "./TypeChecking/Expressions.ag"(line 14, column 9) _lhsOannotatedTree = {-# LINE 14 "./TypeChecking/Expressions.ag" #-} annTypesAndErrors _backTree (tpeToT _tpe ) (getErrors _tpe ) Nothing {-# LINE 3125 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 62, column 9) _tpe = {-# LINE 62 "./TypeChecking/Expressions.ag" #-} dependsOnRTpe _argsItypeList $ typeCheckFunCall _lhsIenv funName_ _argsItypeList {-# LINE 3134 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 67, column 9) _backTree = {-# LINE 67 "./TypeChecking/Expressions.ag" #-} FunCall ann_ funName_ _argsIannotatedTree {-# LINE 3139 "AstInternal.hs" #-} -- "./TypeChecking/SelectLists.ag"(line 165, column 13) _lhsOliftedColumnName = {-# LINE 165 "./TypeChecking/SelectLists.ag" #-} if isOperatorName funName_ then "" else funName_ {-# LINE 3146 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} FunCall ann_ funName_ _argsIannotatedTree {-# LINE 3151 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} FunCall ann_ funName_ _argsIoriginalTree {-# LINE 3156 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 3161 "AstInternal.hs" #-} -- copy rule (down) _argsOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 3166 "AstInternal.hs" #-} -- copy rule (down) _argsOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 3171 "AstInternal.hs" #-} ( _argsIannotatedTree,_argsIoriginalTree,_argsItypeList) = (args_ _argsOenv _argsOlib ) in ( _lhsOannotatedTree,_lhsOliftedColumnName,_lhsOoriginalTree))) sem_Expression_Identifier :: Annotation -> String -> T_Expression sem_Expression_Identifier ann_ i_ = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: Expression _lhsOliftedColumnName :: String _lhsOoriginalTree :: Expression -- "./TypeChecking/Expressions.ag"(line 14, column 9) _lhsOannotatedTree = {-# LINE 14 "./TypeChecking/Expressions.ag" #-} annTypesAndErrors _backTree (tpeToT _tpe ) (getErrors _tpe ) Nothing {-# LINE 3191 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 235, column 9) _tpe = {-# LINE 235 "./TypeChecking/Expressions.ag" #-} libLookupID _lhsIlib i_ {-# LINE 3196 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 236, column 9) _backTree = {-# LINE 236 "./TypeChecking/Expressions.ag" #-} Identifier ann_ i_ {-# LINE 3201 "AstInternal.hs" #-} -- "./TypeChecking/SelectLists.ag"(line 164, column 16) _lhsOliftedColumnName = {-# LINE 164 "./TypeChecking/SelectLists.ag" #-} i_ {-# LINE 3206 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Identifier ann_ i_ {-# LINE 3211 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Identifier ann_ i_ {-# LINE 3216 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 3221 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOliftedColumnName,_lhsOoriginalTree))) sem_Expression_InPredicate :: Annotation -> T_Expression -> Bool -> T_InList -> T_Expression sem_Expression_InPredicate ann_ expr_ i_ list_ = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: Expression _lhsOoriginalTree :: Expression _lhsOliftedColumnName :: String _exprOenv :: Environment _exprOlib :: LocalIdentifierBindings _listOenv :: Environment _listOlib :: LocalIdentifierBindings _exprIannotatedTree :: Expression _exprIliftedColumnName :: String _exprIoriginalTree :: Expression _listIannotatedTree :: InList _listIlistType :: (Either [TypeError] Type) _listIoriginalTree :: InList -- "./TypeChecking/Expressions.ag"(line 14, column 9) _lhsOannotatedTree = {-# LINE 14 "./TypeChecking/Expressions.ag" #-} annTypesAndErrors _backTree (tpeToT _tpe ) (getErrors _tpe ) Nothing {-# LINE 3251 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 283, column 9) _tpe = {-# LINE 283 "./TypeChecking/Expressions.ag" #-} do lt <- _listIlistType ty <- resolveResultSetType _lhsIenv [getTypeAnnotation _exprIannotatedTree, lt] return typeBool {-# LINE 3261 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 289, column 9) _backTree = {-# LINE 289 "./TypeChecking/Expressions.ag" #-} InPredicate ann_ _exprIannotatedTree i_ _listIannotatedTree {-# LINE 3269 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} InPredicate ann_ _exprIannotatedTree i_ _listIannotatedTree {-# LINE 3274 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} InPredicate ann_ _exprIoriginalTree i_ _listIoriginalTree {-# LINE 3279 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 3284 "AstInternal.hs" #-} -- copy rule (up) _lhsOliftedColumnName = {-# LINE 161 "./TypeChecking/SelectLists.ag" #-} _exprIliftedColumnName {-# LINE 3289 "AstInternal.hs" #-} -- copy rule (down) _exprOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 3294 "AstInternal.hs" #-} -- copy rule (down) _exprOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 3299 "AstInternal.hs" #-} -- copy rule (down) _listOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 3304 "AstInternal.hs" #-} -- copy rule (down) _listOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 3309 "AstInternal.hs" #-} ( _exprIannotatedTree,_exprIliftedColumnName,_exprIoriginalTree) = (expr_ _exprOenv _exprOlib ) ( _listIannotatedTree,_listIlistType,_listIoriginalTree) = (list_ _listOenv _listOlib ) in ( _lhsOannotatedTree,_lhsOliftedColumnName,_lhsOoriginalTree))) sem_Expression_IntegerLit :: Annotation -> Integer -> T_Expression sem_Expression_IntegerLit ann_ i_ = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: Expression _lhsOliftedColumnName :: String _lhsOoriginalTree :: Expression -- "./TypeChecking/Expressions.ag"(line 14, column 9) _lhsOannotatedTree = {-# LINE 14 "./TypeChecking/Expressions.ag" #-} annTypesAndErrors _backTree (tpeToT _tpe ) (getErrors _tpe ) Nothing {-# LINE 3331 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 26, column 19) _tpe = {-# LINE 26 "./TypeChecking/Expressions.ag" #-} Right typeInt {-# LINE 3336 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 35, column 9) _backTree = {-# LINE 35 "./TypeChecking/Expressions.ag" #-} IntegerLit ann_ i_ {-# LINE 3341 "AstInternal.hs" #-} -- "./TypeChecking/SelectLists.ag"(line 177, column 7) _lhsOliftedColumnName = {-# LINE 177 "./TypeChecking/SelectLists.ag" #-} "" {-# LINE 3346 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} IntegerLit ann_ i_ {-# LINE 3351 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} IntegerLit ann_ i_ {-# LINE 3356 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 3361 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOliftedColumnName,_lhsOoriginalTree))) sem_Expression_LiftOperator :: Annotation -> String -> T_LiftFlavour -> T_ExpressionList -> T_Expression sem_Expression_LiftOperator ann_ oper_ flav_ args_ = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: Expression _lhsOliftedColumnName :: String _lhsOoriginalTree :: Expression _flavOenv :: Environment _flavOlib :: LocalIdentifierBindings _argsOenv :: Environment _argsOlib :: LocalIdentifierBindings _flavIannotatedTree :: LiftFlavour _flavIoriginalTree :: LiftFlavour _argsIannotatedTree :: ExpressionList _argsIoriginalTree :: ExpressionList _argsItypeList :: ([Type]) -- "./TypeChecking/Expressions.ag"(line 14, column 9) _lhsOannotatedTree = {-# LINE 14 "./TypeChecking/Expressions.ag" #-} annTypesAndErrors _backTree (tpeToT _tpe ) (getErrors _tpe ) Nothing {-# LINE 3390 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 161, column 9) _tpe = {-# LINE 161 "./TypeChecking/Expressions.ag" #-} dependsOnRTpe _argsItypeList $ do let args = _argsIannotatedTree errorWhen (length args /= 2) [AnyAllError $ "must have two args, got " ++ show args] let [a,b] = args aType = getTypeAnnotation a bType = getTypeAnnotation b dependsOnRTpe [aType,bType] $ do errorWhen (not $ isArrayType bType) [AnyAllError $ "second arg must be array, got " ++ show args] elemType <- unwrapArray $ bType resType <- typeCheckFunCall _lhsIenv oper_ [aType,elemType] errorWhen (resType /= typeBool) [AnyAllError $ "operator must have bool return, got " ++ show resType] return resType {-# LINE 3412 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 179, column 9) _backTree = {-# LINE 179 "./TypeChecking/Expressions.ag" #-} LiftOperator ann_ oper_ _flavIannotatedTree _argsIannotatedTree {-# LINE 3417 "AstInternal.hs" #-} -- "./TypeChecking/SelectLists.ag"(line 177, column 7) _lhsOliftedColumnName = {-# LINE 177 "./TypeChecking/SelectLists.ag" #-} "" {-# LINE 3422 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} LiftOperator ann_ oper_ _flavIannotatedTree _argsIannotatedTree {-# LINE 3427 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} LiftOperator ann_ oper_ _flavIoriginalTree _argsIoriginalTree {-# LINE 3432 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 3437 "AstInternal.hs" #-} -- copy rule (down) _flavOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 3442 "AstInternal.hs" #-} -- copy rule (down) _flavOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 3447 "AstInternal.hs" #-} -- copy rule (down) _argsOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 3452 "AstInternal.hs" #-} -- copy rule (down) _argsOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 3457 "AstInternal.hs" #-} ( _flavIannotatedTree,_flavIoriginalTree) = (flav_ _flavOenv _flavOlib ) ( _argsIannotatedTree,_argsIoriginalTree,_argsItypeList) = (args_ _argsOenv _argsOlib ) in ( _lhsOannotatedTree,_lhsOliftedColumnName,_lhsOoriginalTree))) sem_Expression_NullLit :: Annotation -> T_Expression sem_Expression_NullLit ann_ = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: Expression _lhsOliftedColumnName :: String _lhsOoriginalTree :: Expression -- "./TypeChecking/Expressions.ag"(line 14, column 9) _lhsOannotatedTree = {-# LINE 14 "./TypeChecking/Expressions.ag" #-} annTypesAndErrors _backTree (tpeToT _tpe ) (getErrors _tpe ) Nothing {-# LINE 3478 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 31, column 16) _tpe = {-# LINE 31 "./TypeChecking/Expressions.ag" #-} Right UnknownType {-# LINE 3483 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 43, column 9) _backTree = {-# LINE 43 "./TypeChecking/Expressions.ag" #-} NullLit ann_ {-# LINE 3488 "AstInternal.hs" #-} -- "./TypeChecking/SelectLists.ag"(line 177, column 7) _lhsOliftedColumnName = {-# LINE 177 "./TypeChecking/SelectLists.ag" #-} "" {-# LINE 3493 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} NullLit ann_ {-# LINE 3498 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} NullLit ann_ {-# LINE 3503 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 3508 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOliftedColumnName,_lhsOoriginalTree))) sem_Expression_Placeholder :: Annotation -> T_Expression sem_Expression_Placeholder ann_ = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: Expression _lhsOliftedColumnName :: String _lhsOoriginalTree :: Expression -- "./TypeChecking/Expressions.ag"(line 14, column 9) _lhsOannotatedTree = {-# LINE 14 "./TypeChecking/Expressions.ag" #-} annTypesAndErrors _backTree (tpeToT _tpe ) (getErrors _tpe ) Nothing {-# LINE 3525 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 247, column 9) _tpe = {-# LINE 247 "./TypeChecking/Expressions.ag" #-} Right UnknownType {-# LINE 3530 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 248, column 9) _backTree = {-# LINE 248 "./TypeChecking/Expressions.ag" #-} Placeholder ann_ {-# LINE 3535 "AstInternal.hs" #-} -- "./TypeChecking/SelectLists.ag"(line 177, column 7) _lhsOliftedColumnName = {-# LINE 177 "./TypeChecking/SelectLists.ag" #-} "" {-# LINE 3540 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Placeholder ann_ {-# LINE 3545 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Placeholder ann_ {-# LINE 3550 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 3555 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOliftedColumnName,_lhsOoriginalTree))) sem_Expression_PositionalArg :: Annotation -> Integer -> T_Expression sem_Expression_PositionalArg ann_ p_ = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: Expression _lhsOliftedColumnName :: String _lhsOoriginalTree :: Expression -- "./TypeChecking/Expressions.ag"(line 14, column 9) _lhsOannotatedTree = {-# LINE 14 "./TypeChecking/Expressions.ag" #-} annTypesAndErrors _backTree (tpeToT _tpe ) (getErrors _tpe ) Nothing {-# LINE 3573 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 241, column 9) _tpe = {-# LINE 241 "./TypeChecking/Expressions.ag" #-} libLookupID _lhsIlib ('$':show p_) {-# LINE 3578 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 242, column 9) _backTree = {-# LINE 242 "./TypeChecking/Expressions.ag" #-} PositionalArg ann_ p_ {-# LINE 3583 "AstInternal.hs" #-} -- "./TypeChecking/SelectLists.ag"(line 177, column 7) _lhsOliftedColumnName = {-# LINE 177 "./TypeChecking/SelectLists.ag" #-} "" {-# LINE 3588 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} PositionalArg ann_ p_ {-# LINE 3593 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} PositionalArg ann_ p_ {-# LINE 3598 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 3603 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOliftedColumnName,_lhsOoriginalTree))) sem_Expression_ScalarSubQuery :: Annotation -> T_SelectExpression -> T_Expression sem_Expression_ScalarSubQuery ann_ sel_ = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: Expression _lhsOliftedColumnName :: String _lhsOoriginalTree :: Expression _selOenv :: Environment _selOlib :: LocalIdentifierBindings _selIannotatedTree :: SelectExpression _selIlibUpdates :: ([LocalIdentifierBindingsUpdate]) _selIoriginalTree :: SelectExpression -- "./TypeChecking/Expressions.ag"(line 14, column 9) _lhsOannotatedTree = {-# LINE 14 "./TypeChecking/Expressions.ag" #-} annTypesAndErrors _backTree (tpeToT _tpe ) (getErrors _tpe ) Nothing {-# LINE 3626 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 265, column 9) _tpe = {-# LINE 265 "./TypeChecking/Expressions.ag" #-} do let selType = getTypeAnnotation _selIannotatedTree dependsOnRTpe [selType] $ do f <- map snd <$> unwrapSetOfComposite selType case length f of 0 -> Left [InternalError "no columns in scalar subquery?"] 1 -> Right $ head f _ -> Right $ AnonymousRecordType f {-# LINE 3638 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 275, column 9) _backTree = {-# LINE 275 "./TypeChecking/Expressions.ag" #-} ScalarSubQuery ann_ _selIannotatedTree {-# LINE 3643 "AstInternal.hs" #-} -- "./TypeChecking/SelectLists.ag"(line 177, column 7) _lhsOliftedColumnName = {-# LINE 177 "./TypeChecking/SelectLists.ag" #-} "" {-# LINE 3648 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} ScalarSubQuery ann_ _selIannotatedTree {-# LINE 3653 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} ScalarSubQuery ann_ _selIoriginalTree {-# LINE 3658 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 3663 "AstInternal.hs" #-} -- copy rule (down) _selOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 3668 "AstInternal.hs" #-} -- copy rule (down) _selOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 3673 "AstInternal.hs" #-} ( _selIannotatedTree,_selIlibUpdates,_selIoriginalTree) = (sel_ _selOenv _selOlib ) in ( _lhsOannotatedTree,_lhsOliftedColumnName,_lhsOoriginalTree))) sem_Expression_StringLit :: Annotation -> String -> String -> T_Expression sem_Expression_StringLit ann_ quote_ value_ = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: Expression _lhsOliftedColumnName :: String _lhsOoriginalTree :: Expression -- "./TypeChecking/Expressions.ag"(line 14, column 9) _lhsOannotatedTree = {-# LINE 14 "./TypeChecking/Expressions.ag" #-} annTypesAndErrors _backTree (tpeToT _tpe ) (getErrors _tpe ) Nothing {-# LINE 3694 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 27, column 18) _tpe = {-# LINE 27 "./TypeChecking/Expressions.ag" #-} Right UnknownType {-# LINE 3699 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 37, column 9) _backTree = {-# LINE 37 "./TypeChecking/Expressions.ag" #-} StringLit ann_ quote_ value_ {-# LINE 3704 "AstInternal.hs" #-} -- "./TypeChecking/SelectLists.ag"(line 177, column 7) _lhsOliftedColumnName = {-# LINE 177 "./TypeChecking/SelectLists.ag" #-} "" {-# LINE 3709 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} StringLit ann_ quote_ value_ {-# LINE 3714 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} StringLit ann_ quote_ value_ {-# LINE 3719 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 3724 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOliftedColumnName,_lhsOoriginalTree))) sem_Expression_WindowFn :: Annotation -> T_Expression -> T_ExpressionList -> T_ExpressionList -> T_Direction -> T_FrameClause -> T_Expression sem_Expression_WindowFn ann_ fn_ partitionBy_ orderBy_ dir_ frm_ = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: Expression _lhsOoriginalTree :: Expression _lhsOliftedColumnName :: String _fnOenv :: Environment _fnOlib :: LocalIdentifierBindings _partitionByOenv :: Environment _partitionByOlib :: LocalIdentifierBindings _orderByOenv :: Environment _orderByOlib :: LocalIdentifierBindings _dirOenv :: Environment _dirOlib :: LocalIdentifierBindings _frmOenv :: Environment _frmOlib :: LocalIdentifierBindings _fnIannotatedTree :: Expression _fnIliftedColumnName :: String _fnIoriginalTree :: Expression _partitionByIannotatedTree :: ExpressionList _partitionByIoriginalTree :: ExpressionList _partitionByItypeList :: ([Type]) _orderByIannotatedTree :: ExpressionList _orderByIoriginalTree :: ExpressionList _orderByItypeList :: ([Type]) _dirIannotatedTree :: Direction _dirIoriginalTree :: Direction _frmIannotatedTree :: FrameClause _frmIoriginalTree :: FrameClause -- "./TypeChecking/Expressions.ag"(line 14, column 9) _lhsOannotatedTree = {-# LINE 14 "./TypeChecking/Expressions.ag" #-} annTypesAndErrors _backTree (tpeToT _tpe ) (getErrors _tpe ) Nothing {-# LINE 3769 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 71, column 9) _tpe = {-# LINE 71 "./TypeChecking/Expressions.ag" #-} Right (getTypeAnnotation _fnIannotatedTree) {-# LINE 3774 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 72, column 9) _backTree = {-# LINE 72 "./TypeChecking/Expressions.ag" #-} WindowFn ann_ _fnIannotatedTree _partitionByIannotatedTree _orderByIannotatedTree _dirIannotatedTree _frmIannotatedTree {-# LINE 3784 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} WindowFn ann_ _fnIannotatedTree _partitionByIannotatedTree _orderByIannotatedTree _dirIannotatedTree _frmIannotatedTree {-# LINE 3789 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} WindowFn ann_ _fnIoriginalTree _partitionByIoriginalTree _orderByIoriginalTree _dirIoriginalTree _frmIoriginalTree {-# LINE 3794 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 3799 "AstInternal.hs" #-} -- copy rule (up) _lhsOliftedColumnName = {-# LINE 161 "./TypeChecking/SelectLists.ag" #-} _fnIliftedColumnName {-# LINE 3804 "AstInternal.hs" #-} -- copy rule (down) _fnOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 3809 "AstInternal.hs" #-} -- copy rule (down) _fnOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 3814 "AstInternal.hs" #-} -- copy rule (down) _partitionByOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 3819 "AstInternal.hs" #-} -- copy rule (down) _partitionByOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 3824 "AstInternal.hs" #-} -- copy rule (down) _orderByOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 3829 "AstInternal.hs" #-} -- copy rule (down) _orderByOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 3834 "AstInternal.hs" #-} -- copy rule (down) _dirOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 3839 "AstInternal.hs" #-} -- copy rule (down) _dirOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 3844 "AstInternal.hs" #-} -- copy rule (down) _frmOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 3849 "AstInternal.hs" #-} -- copy rule (down) _frmOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 3854 "AstInternal.hs" #-} ( _fnIannotatedTree,_fnIliftedColumnName,_fnIoriginalTree) = (fn_ _fnOenv _fnOlib ) ( _partitionByIannotatedTree,_partitionByIoriginalTree,_partitionByItypeList) = (partitionBy_ _partitionByOenv _partitionByOlib ) ( _orderByIannotatedTree,_orderByIoriginalTree,_orderByItypeList) = (orderBy_ _orderByOenv _orderByOlib ) ( _dirIannotatedTree,_dirIoriginalTree) = (dir_ _dirOenv _dirOlib ) ( _frmIannotatedTree,_frmIoriginalTree) = (frm_ _frmOenv _frmOlib ) in ( _lhsOannotatedTree,_lhsOliftedColumnName,_lhsOoriginalTree))) -- ExpressionDirectionPair ------------------------------------- {- visit 0: inherited attributes: env : Environment lib : LocalIdentifierBindings synthesized attributes: annotatedTree : SELF originalTree : SELF alternatives: alternative Tuple: child x1 : Expression child x2 : Direction visit 0: local annotatedTree : _ local originalTree : _ -} type ExpressionDirectionPair = ( (Expression),(Direction)) -- cata sem_ExpressionDirectionPair :: ExpressionDirectionPair -> T_ExpressionDirectionPair sem_ExpressionDirectionPair ( x1,x2) = (sem_ExpressionDirectionPair_Tuple (sem_Expression x1 ) (sem_Direction x2 ) ) -- semantic domain type T_ExpressionDirectionPair = Environment -> LocalIdentifierBindings -> ( ExpressionDirectionPair,ExpressionDirectionPair) data Inh_ExpressionDirectionPair = Inh_ExpressionDirectionPair {env_Inh_ExpressionDirectionPair :: Environment,lib_Inh_ExpressionDirectionPair :: LocalIdentifierBindings} data Syn_ExpressionDirectionPair = Syn_ExpressionDirectionPair {annotatedTree_Syn_ExpressionDirectionPair :: ExpressionDirectionPair,originalTree_Syn_ExpressionDirectionPair :: ExpressionDirectionPair} wrap_ExpressionDirectionPair :: T_ExpressionDirectionPair -> Inh_ExpressionDirectionPair -> Syn_ExpressionDirectionPair wrap_ExpressionDirectionPair sem (Inh_ExpressionDirectionPair _lhsIenv _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIenv _lhsIlib ) in (Syn_ExpressionDirectionPair _lhsOannotatedTree _lhsOoriginalTree )) sem_ExpressionDirectionPair_Tuple :: T_Expression -> T_Direction -> T_ExpressionDirectionPair sem_ExpressionDirectionPair_Tuple x1_ x2_ = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: ExpressionDirectionPair _lhsOoriginalTree :: ExpressionDirectionPair _x1Oenv :: Environment _x1Olib :: LocalIdentifierBindings _x2Oenv :: Environment _x2Olib :: LocalIdentifierBindings _x1IannotatedTree :: Expression _x1IliftedColumnName :: String _x1IoriginalTree :: Expression _x2IannotatedTree :: Direction _x2IoriginalTree :: Direction -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} (_x1IannotatedTree,_x2IannotatedTree) {-# LINE 3923 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} (_x1IoriginalTree,_x2IoriginalTree) {-# LINE 3928 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 3933 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 3938 "AstInternal.hs" #-} -- copy rule (down) _x1Oenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 3943 "AstInternal.hs" #-} -- copy rule (down) _x1Olib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 3948 "AstInternal.hs" #-} -- copy rule (down) _x2Oenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 3953 "AstInternal.hs" #-} -- copy rule (down) _x2Olib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 3958 "AstInternal.hs" #-} ( _x1IannotatedTree,_x1IliftedColumnName,_x1IoriginalTree) = (x1_ _x1Oenv _x1Olib ) ( _x2IannotatedTree,_x2IoriginalTree) = (x2_ _x2Oenv _x2Olib ) in ( _lhsOannotatedTree,_lhsOoriginalTree))) -- ExpressionDirectionPairList --------------------------------- {- visit 0: inherited attributes: env : Environment lib : LocalIdentifierBindings synthesized attributes: annotatedTree : SELF originalTree : SELF alternatives: alternative Cons: child hd : ExpressionDirectionPair child tl : ExpressionDirectionPairList visit 0: local annotatedTree : _ local originalTree : _ alternative Nil: visit 0: local annotatedTree : _ local originalTree : _ -} type ExpressionDirectionPairList = [(ExpressionDirectionPair)] -- cata sem_ExpressionDirectionPairList :: ExpressionDirectionPairList -> T_ExpressionDirectionPairList sem_ExpressionDirectionPairList list = (Prelude.foldr sem_ExpressionDirectionPairList_Cons sem_ExpressionDirectionPairList_Nil (Prelude.map sem_ExpressionDirectionPair list) ) -- semantic domain type T_ExpressionDirectionPairList = Environment -> LocalIdentifierBindings -> ( ExpressionDirectionPairList,ExpressionDirectionPairList) data Inh_ExpressionDirectionPairList = Inh_ExpressionDirectionPairList {env_Inh_ExpressionDirectionPairList :: Environment,lib_Inh_ExpressionDirectionPairList :: LocalIdentifierBindings} data Syn_ExpressionDirectionPairList = Syn_ExpressionDirectionPairList {annotatedTree_Syn_ExpressionDirectionPairList :: ExpressionDirectionPairList,originalTree_Syn_ExpressionDirectionPairList :: ExpressionDirectionPairList} wrap_ExpressionDirectionPairList :: T_ExpressionDirectionPairList -> Inh_ExpressionDirectionPairList -> Syn_ExpressionDirectionPairList wrap_ExpressionDirectionPairList sem (Inh_ExpressionDirectionPairList _lhsIenv _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIenv _lhsIlib ) in (Syn_ExpressionDirectionPairList _lhsOannotatedTree _lhsOoriginalTree )) sem_ExpressionDirectionPairList_Cons :: T_ExpressionDirectionPair -> T_ExpressionDirectionPairList -> T_ExpressionDirectionPairList sem_ExpressionDirectionPairList_Cons hd_ tl_ = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: ExpressionDirectionPairList _lhsOoriginalTree :: ExpressionDirectionPairList _hdOenv :: Environment _hdOlib :: LocalIdentifierBindings _tlOenv :: Environment _tlOlib :: LocalIdentifierBindings _hdIannotatedTree :: ExpressionDirectionPair _hdIoriginalTree :: ExpressionDirectionPair _tlIannotatedTree :: ExpressionDirectionPairList _tlIoriginalTree :: ExpressionDirectionPairList -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} (:) _hdIannotatedTree _tlIannotatedTree {-# LINE 4024 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} (:) _hdIoriginalTree _tlIoriginalTree {-# LINE 4029 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 4034 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 4039 "AstInternal.hs" #-} -- copy rule (down) _hdOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 4044 "AstInternal.hs" #-} -- copy rule (down) _hdOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 4049 "AstInternal.hs" #-} -- copy rule (down) _tlOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 4054 "AstInternal.hs" #-} -- copy rule (down) _tlOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 4059 "AstInternal.hs" #-} ( _hdIannotatedTree,_hdIoriginalTree) = (hd_ _hdOenv _hdOlib ) ( _tlIannotatedTree,_tlIoriginalTree) = (tl_ _tlOenv _tlOlib ) in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_ExpressionDirectionPairList_Nil :: T_ExpressionDirectionPairList sem_ExpressionDirectionPairList_Nil = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: ExpressionDirectionPairList _lhsOoriginalTree :: ExpressionDirectionPairList -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 4075 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 4080 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 4085 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 4090 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) -- ExpressionList ---------------------------------------------- {- visit 0: inherited attributes: env : Environment lib : LocalIdentifierBindings synthesized attributes: annotatedTree : SELF originalTree : SELF typeList : [Type] alternatives: alternative Cons: child hd : Expression child tl : ExpressionList visit 0: local annotatedTree : _ local originalTree : _ alternative Nil: visit 0: local annotatedTree : _ local originalTree : _ -} type ExpressionList = [(Expression)] -- cata sem_ExpressionList :: ExpressionList -> T_ExpressionList sem_ExpressionList list = (Prelude.foldr sem_ExpressionList_Cons sem_ExpressionList_Nil (Prelude.map sem_Expression list) ) -- semantic domain type T_ExpressionList = Environment -> LocalIdentifierBindings -> ( ExpressionList,ExpressionList,([Type])) data Inh_ExpressionList = Inh_ExpressionList {env_Inh_ExpressionList :: Environment,lib_Inh_ExpressionList :: LocalIdentifierBindings} data Syn_ExpressionList = Syn_ExpressionList {annotatedTree_Syn_ExpressionList :: ExpressionList,originalTree_Syn_ExpressionList :: ExpressionList,typeList_Syn_ExpressionList :: [Type]} wrap_ExpressionList :: T_ExpressionList -> Inh_ExpressionList -> Syn_ExpressionList wrap_ExpressionList sem (Inh_ExpressionList _lhsIenv _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree,_lhsOtypeList) = (sem _lhsIenv _lhsIlib ) in (Syn_ExpressionList _lhsOannotatedTree _lhsOoriginalTree _lhsOtypeList )) sem_ExpressionList_Cons :: T_Expression -> T_ExpressionList -> T_ExpressionList sem_ExpressionList_Cons hd_ tl_ = (\ _lhsIenv _lhsIlib -> (let _lhsOtypeList :: ([Type]) _lhsOannotatedTree :: ExpressionList _lhsOoriginalTree :: ExpressionList _hdOenv :: Environment _hdOlib :: LocalIdentifierBindings _tlOenv :: Environment _tlOlib :: LocalIdentifierBindings _hdIannotatedTree :: Expression _hdIliftedColumnName :: String _hdIoriginalTree :: Expression _tlIannotatedTree :: ExpressionList _tlIoriginalTree :: ExpressionList _tlItypeList :: ([Type]) -- "./TypeChecking/Misc.ag"(line 52, column 12) _lhsOtypeList = {-# LINE 52 "./TypeChecking/Misc.ag" #-} getTypeAnnotation _hdIannotatedTree : _tlItypeList {-# LINE 4156 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} (:) _hdIannotatedTree _tlIannotatedTree {-# LINE 4161 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} (:) _hdIoriginalTree _tlIoriginalTree {-# LINE 4166 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 4171 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 4176 "AstInternal.hs" #-} -- copy rule (down) _hdOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 4181 "AstInternal.hs" #-} -- copy rule (down) _hdOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 4186 "AstInternal.hs" #-} -- copy rule (down) _tlOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 4191 "AstInternal.hs" #-} -- copy rule (down) _tlOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 4196 "AstInternal.hs" #-} ( _hdIannotatedTree,_hdIliftedColumnName,_hdIoriginalTree) = (hd_ _hdOenv _hdOlib ) ( _tlIannotatedTree,_tlIoriginalTree,_tlItypeList) = (tl_ _tlOenv _tlOlib ) in ( _lhsOannotatedTree,_lhsOoriginalTree,_lhsOtypeList))) sem_ExpressionList_Nil :: T_ExpressionList sem_ExpressionList_Nil = (\ _lhsIenv _lhsIlib -> (let _lhsOtypeList :: ([Type]) _lhsOannotatedTree :: ExpressionList _lhsOoriginalTree :: ExpressionList -- "./TypeChecking/Misc.ag"(line 53, column 11) _lhsOtypeList = {-# LINE 53 "./TypeChecking/Misc.ag" #-} [] {-# LINE 4213 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 4218 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 4223 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 4228 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 4233 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree,_lhsOtypeList))) -- ExpressionListList ------------------------------------------ {- visit 0: inherited attributes: env : Environment lib : LocalIdentifierBindings synthesized attributes: annotatedTree : SELF originalTree : SELF typeListList : [[Type]] alternatives: alternative Cons: child hd : ExpressionList child tl : ExpressionListList visit 0: local annotatedTree : _ local originalTree : _ alternative Nil: visit 0: local annotatedTree : _ local originalTree : _ -} type ExpressionListList = [(ExpressionList)] -- cata sem_ExpressionListList :: ExpressionListList -> T_ExpressionListList sem_ExpressionListList list = (Prelude.foldr sem_ExpressionListList_Cons sem_ExpressionListList_Nil (Prelude.map sem_ExpressionList list) ) -- semantic domain type T_ExpressionListList = Environment -> LocalIdentifierBindings -> ( ExpressionListList,ExpressionListList,([[Type]])) data Inh_ExpressionListList = Inh_ExpressionListList {env_Inh_ExpressionListList :: Environment,lib_Inh_ExpressionListList :: LocalIdentifierBindings} data Syn_ExpressionListList = Syn_ExpressionListList {annotatedTree_Syn_ExpressionListList :: ExpressionListList,originalTree_Syn_ExpressionListList :: ExpressionListList,typeListList_Syn_ExpressionListList :: [[Type]]} wrap_ExpressionListList :: T_ExpressionListList -> Inh_ExpressionListList -> Syn_ExpressionListList wrap_ExpressionListList sem (Inh_ExpressionListList _lhsIenv _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree,_lhsOtypeListList) = (sem _lhsIenv _lhsIlib ) in (Syn_ExpressionListList _lhsOannotatedTree _lhsOoriginalTree _lhsOtypeListList )) sem_ExpressionListList_Cons :: T_ExpressionList -> T_ExpressionListList -> T_ExpressionListList sem_ExpressionListList_Cons hd_ tl_ = (\ _lhsIenv _lhsIlib -> (let _lhsOtypeListList :: ([[Type]]) _lhsOannotatedTree :: ExpressionListList _lhsOoriginalTree :: ExpressionListList _hdOenv :: Environment _hdOlib :: LocalIdentifierBindings _tlOenv :: Environment _tlOlib :: LocalIdentifierBindings _hdIannotatedTree :: ExpressionList _hdIoriginalTree :: ExpressionList _hdItypeList :: ([Type]) _tlIannotatedTree :: ExpressionListList _tlIoriginalTree :: ExpressionListList _tlItypeListList :: ([[Type]]) -- "./TypeChecking/Misc.ag"(line 59, column 12) _lhsOtypeListList = {-# LINE 59 "./TypeChecking/Misc.ag" #-} _hdItypeList : _tlItypeListList {-# LINE 4299 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} (:) _hdIannotatedTree _tlIannotatedTree {-# LINE 4304 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} (:) _hdIoriginalTree _tlIoriginalTree {-# LINE 4309 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 4314 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 4319 "AstInternal.hs" #-} -- copy rule (down) _hdOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 4324 "AstInternal.hs" #-} -- copy rule (down) _hdOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 4329 "AstInternal.hs" #-} -- copy rule (down) _tlOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 4334 "AstInternal.hs" #-} -- copy rule (down) _tlOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 4339 "AstInternal.hs" #-} ( _hdIannotatedTree,_hdIoriginalTree,_hdItypeList) = (hd_ _hdOenv _hdOlib ) ( _tlIannotatedTree,_tlIoriginalTree,_tlItypeListList) = (tl_ _tlOenv _tlOlib ) in ( _lhsOannotatedTree,_lhsOoriginalTree,_lhsOtypeListList))) sem_ExpressionListList_Nil :: T_ExpressionListList sem_ExpressionListList_Nil = (\ _lhsIenv _lhsIlib -> (let _lhsOtypeListList :: ([[Type]]) _lhsOannotatedTree :: ExpressionListList _lhsOoriginalTree :: ExpressionListList -- "./TypeChecking/Misc.ag"(line 60, column 11) _lhsOtypeListList = {-# LINE 60 "./TypeChecking/Misc.ag" #-} [] {-# LINE 4356 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 4361 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 4366 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 4371 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 4376 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree,_lhsOtypeListList))) -- ExpressionListStatementListPair ----------------------------- {- visit 0: inherited attributes: env : Environment lib : LocalIdentifierBindings synthesized attributes: annotatedTree : SELF originalTree : SELF alternatives: alternative Tuple: child x1 : ExpressionList child x2 : StatementList visit 0: local annotatedTree : _ local originalTree : _ -} type ExpressionListStatementListPair = ( (ExpressionList),(StatementList)) -- cata sem_ExpressionListStatementListPair :: ExpressionListStatementListPair -> T_ExpressionListStatementListPair sem_ExpressionListStatementListPair ( x1,x2) = (sem_ExpressionListStatementListPair_Tuple (sem_ExpressionList x1 ) (sem_StatementList x2 ) ) -- semantic domain type T_ExpressionListStatementListPair = Environment -> LocalIdentifierBindings -> ( ExpressionListStatementListPair,ExpressionListStatementListPair) data Inh_ExpressionListStatementListPair = Inh_ExpressionListStatementListPair {env_Inh_ExpressionListStatementListPair :: Environment,lib_Inh_ExpressionListStatementListPair :: LocalIdentifierBindings} data Syn_ExpressionListStatementListPair = Syn_ExpressionListStatementListPair {annotatedTree_Syn_ExpressionListStatementListPair :: ExpressionListStatementListPair,originalTree_Syn_ExpressionListStatementListPair :: ExpressionListStatementListPair} wrap_ExpressionListStatementListPair :: T_ExpressionListStatementListPair -> Inh_ExpressionListStatementListPair -> Syn_ExpressionListStatementListPair wrap_ExpressionListStatementListPair sem (Inh_ExpressionListStatementListPair _lhsIenv _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIenv _lhsIlib ) in (Syn_ExpressionListStatementListPair _lhsOannotatedTree _lhsOoriginalTree )) sem_ExpressionListStatementListPair_Tuple :: T_ExpressionList -> T_StatementList -> T_ExpressionListStatementListPair sem_ExpressionListStatementListPair_Tuple x1_ x2_ = (\ _lhsIenv _lhsIlib -> (let _x2OenvUpdates :: ([EnvironmentUpdate]) _x2OlibUpdates :: ([LocalIdentifierBindingsUpdate]) _lhsOannotatedTree :: ExpressionListStatementListPair _lhsOoriginalTree :: ExpressionListStatementListPair _x1Oenv :: Environment _x1Olib :: LocalIdentifierBindings _x2Oenv :: Environment _x2Olib :: LocalIdentifierBindings _x1IannotatedTree :: ExpressionList _x1IoriginalTree :: ExpressionList _x1ItypeList :: ([Type]) _x2IannotatedTree :: StatementList _x2IoriginalTree :: StatementList _x2IproducedEnv :: Environment _x2IproducedLib :: LocalIdentifierBindings -- "./TypeChecking/Statements.ag"(line 94, column 9) _x2OenvUpdates = {-# LINE 94 "./TypeChecking/Statements.ag" #-} [] {-# LINE 4439 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 95, column 9) _x2OlibUpdates = {-# LINE 95 "./TypeChecking/Statements.ag" #-} [] {-# LINE 4444 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} (_x1IannotatedTree,_x2IannotatedTree) {-# LINE 4449 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} (_x1IoriginalTree,_x2IoriginalTree) {-# LINE 4454 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 4459 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 4464 "AstInternal.hs" #-} -- copy rule (down) _x1Oenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 4469 "AstInternal.hs" #-} -- copy rule (down) _x1Olib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 4474 "AstInternal.hs" #-} -- copy rule (down) _x2Oenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 4479 "AstInternal.hs" #-} -- copy rule (down) _x2Olib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 4484 "AstInternal.hs" #-} ( _x1IannotatedTree,_x1IoriginalTree,_x1ItypeList) = (x1_ _x1Oenv _x1Olib ) ( _x2IannotatedTree,_x2IoriginalTree,_x2IproducedEnv,_x2IproducedLib) = (x2_ _x2Oenv _x2OenvUpdates _x2Olib _x2OlibUpdates ) in ( _lhsOannotatedTree,_lhsOoriginalTree))) -- ExpressionListStatementListPairList ------------------------- {- visit 0: inherited attributes: env : Environment lib : LocalIdentifierBindings synthesized attributes: annotatedTree : SELF originalTree : SELF alternatives: alternative Cons: child hd : ExpressionListStatementListPair child tl : ExpressionListStatementListPairList visit 0: local annotatedTree : _ local originalTree : _ alternative Nil: visit 0: local annotatedTree : _ local originalTree : _ -} type ExpressionListStatementListPairList = [(ExpressionListStatementListPair)] -- cata sem_ExpressionListStatementListPairList :: ExpressionListStatementListPairList -> T_ExpressionListStatementListPairList sem_ExpressionListStatementListPairList list = (Prelude.foldr sem_ExpressionListStatementListPairList_Cons sem_ExpressionListStatementListPairList_Nil (Prelude.map sem_ExpressionListStatementListPair list) ) -- semantic domain type T_ExpressionListStatementListPairList = Environment -> LocalIdentifierBindings -> ( ExpressionListStatementListPairList,ExpressionListStatementListPairList) data Inh_ExpressionListStatementListPairList = Inh_ExpressionListStatementListPairList {env_Inh_ExpressionListStatementListPairList :: Environment,lib_Inh_ExpressionListStatementListPairList :: LocalIdentifierBindings} data Syn_ExpressionListStatementListPairList = Syn_ExpressionListStatementListPairList {annotatedTree_Syn_ExpressionListStatementListPairList :: ExpressionListStatementListPairList,originalTree_Syn_ExpressionListStatementListPairList :: ExpressionListStatementListPairList} wrap_ExpressionListStatementListPairList :: T_ExpressionListStatementListPairList -> Inh_ExpressionListStatementListPairList -> Syn_ExpressionListStatementListPairList wrap_ExpressionListStatementListPairList sem (Inh_ExpressionListStatementListPairList _lhsIenv _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIenv _lhsIlib ) in (Syn_ExpressionListStatementListPairList _lhsOannotatedTree _lhsOoriginalTree )) sem_ExpressionListStatementListPairList_Cons :: T_ExpressionListStatementListPair -> T_ExpressionListStatementListPairList -> T_ExpressionListStatementListPairList sem_ExpressionListStatementListPairList_Cons hd_ tl_ = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: ExpressionListStatementListPairList _lhsOoriginalTree :: ExpressionListStatementListPairList _hdOenv :: Environment _hdOlib :: LocalIdentifierBindings _tlOenv :: Environment _tlOlib :: LocalIdentifierBindings _hdIannotatedTree :: ExpressionListStatementListPair _hdIoriginalTree :: ExpressionListStatementListPair _tlIannotatedTree :: ExpressionListStatementListPairList _tlIoriginalTree :: ExpressionListStatementListPairList -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} (:) _hdIannotatedTree _tlIannotatedTree {-# LINE 4550 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} (:) _hdIoriginalTree _tlIoriginalTree {-# LINE 4555 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 4560 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 4565 "AstInternal.hs" #-} -- copy rule (down) _hdOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 4570 "AstInternal.hs" #-} -- copy rule (down) _hdOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 4575 "AstInternal.hs" #-} -- copy rule (down) _tlOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 4580 "AstInternal.hs" #-} -- copy rule (down) _tlOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 4585 "AstInternal.hs" #-} ( _hdIannotatedTree,_hdIoriginalTree) = (hd_ _hdOenv _hdOlib ) ( _tlIannotatedTree,_tlIoriginalTree) = (tl_ _tlOenv _tlOlib ) in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_ExpressionListStatementListPairList_Nil :: T_ExpressionListStatementListPairList sem_ExpressionListStatementListPairList_Nil = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: ExpressionListStatementListPairList _lhsOoriginalTree :: ExpressionListStatementListPairList -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 4601 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 4606 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 4611 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 4616 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) -- ExpressionRoot ---------------------------------------------- {- visit 0: inherited attributes: env : Environment lib : LocalIdentifierBindings synthesized attributes: annotatedTree : SELF originalTree : SELF alternatives: alternative ExpressionRoot: child expr : Expression visit 0: local annotatedTree : _ local originalTree : _ -} data ExpressionRoot = ExpressionRoot (Expression) deriving ( Show) -- cata sem_ExpressionRoot :: ExpressionRoot -> T_ExpressionRoot sem_ExpressionRoot (ExpressionRoot _expr ) = (sem_ExpressionRoot_ExpressionRoot (sem_Expression _expr ) ) -- semantic domain type T_ExpressionRoot = Environment -> LocalIdentifierBindings -> ( ExpressionRoot,ExpressionRoot) data Inh_ExpressionRoot = Inh_ExpressionRoot {env_Inh_ExpressionRoot :: Environment,lib_Inh_ExpressionRoot :: LocalIdentifierBindings} data Syn_ExpressionRoot = Syn_ExpressionRoot {annotatedTree_Syn_ExpressionRoot :: ExpressionRoot,originalTree_Syn_ExpressionRoot :: ExpressionRoot} wrap_ExpressionRoot :: T_ExpressionRoot -> Inh_ExpressionRoot -> Syn_ExpressionRoot wrap_ExpressionRoot sem (Inh_ExpressionRoot _lhsIenv _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIenv _lhsIlib ) in (Syn_ExpressionRoot _lhsOannotatedTree _lhsOoriginalTree )) sem_ExpressionRoot_ExpressionRoot :: T_Expression -> T_ExpressionRoot sem_ExpressionRoot_ExpressionRoot expr_ = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: ExpressionRoot _lhsOoriginalTree :: ExpressionRoot _exprOenv :: Environment _exprOlib :: LocalIdentifierBindings _exprIannotatedTree :: Expression _exprIliftedColumnName :: String _exprIoriginalTree :: Expression -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} ExpressionRoot _exprIannotatedTree {-# LINE 4670 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} ExpressionRoot _exprIoriginalTree {-# LINE 4675 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 4680 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 4685 "AstInternal.hs" #-} -- copy rule (down) _exprOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 4690 "AstInternal.hs" #-} -- copy rule (down) _exprOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 4695 "AstInternal.hs" #-} ( _exprIannotatedTree,_exprIliftedColumnName,_exprIoriginalTree) = (expr_ _exprOenv _exprOlib ) in ( _lhsOannotatedTree,_lhsOoriginalTree))) -- ExpressionStatementListPair --------------------------------- {- visit 0: inherited attributes: env : Environment lib : LocalIdentifierBindings synthesized attributes: annotatedTree : SELF originalTree : SELF alternatives: alternative Tuple: child x1 : Expression child x2 : StatementList visit 0: local annotatedTree : _ local originalTree : _ -} type ExpressionStatementListPair = ( (Expression),(StatementList)) -- cata sem_ExpressionStatementListPair :: ExpressionStatementListPair -> T_ExpressionStatementListPair sem_ExpressionStatementListPair ( x1,x2) = (sem_ExpressionStatementListPair_Tuple (sem_Expression x1 ) (sem_StatementList x2 ) ) -- semantic domain type T_ExpressionStatementListPair = Environment -> LocalIdentifierBindings -> ( ExpressionStatementListPair,ExpressionStatementListPair) data Inh_ExpressionStatementListPair = Inh_ExpressionStatementListPair {env_Inh_ExpressionStatementListPair :: Environment,lib_Inh_ExpressionStatementListPair :: LocalIdentifierBindings} data Syn_ExpressionStatementListPair = Syn_ExpressionStatementListPair {annotatedTree_Syn_ExpressionStatementListPair :: ExpressionStatementListPair,originalTree_Syn_ExpressionStatementListPair :: ExpressionStatementListPair} wrap_ExpressionStatementListPair :: T_ExpressionStatementListPair -> Inh_ExpressionStatementListPair -> Syn_ExpressionStatementListPair wrap_ExpressionStatementListPair sem (Inh_ExpressionStatementListPair _lhsIenv _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIenv _lhsIlib ) in (Syn_ExpressionStatementListPair _lhsOannotatedTree _lhsOoriginalTree )) sem_ExpressionStatementListPair_Tuple :: T_Expression -> T_StatementList -> T_ExpressionStatementListPair sem_ExpressionStatementListPair_Tuple x1_ x2_ = (\ _lhsIenv _lhsIlib -> (let _x2OenvUpdates :: ([EnvironmentUpdate]) _x2OlibUpdates :: ([LocalIdentifierBindingsUpdate]) _lhsOannotatedTree :: ExpressionStatementListPair _lhsOoriginalTree :: ExpressionStatementListPair _x1Oenv :: Environment _x1Olib :: LocalIdentifierBindings _x2Oenv :: Environment _x2Olib :: LocalIdentifierBindings _x1IannotatedTree :: Expression _x1IliftedColumnName :: String _x1IoriginalTree :: Expression _x2IannotatedTree :: StatementList _x2IoriginalTree :: StatementList _x2IproducedEnv :: Environment _x2IproducedLib :: LocalIdentifierBindings -- "./TypeChecking/Statements.ag"(line 98, column 9) _x2OenvUpdates = {-# LINE 98 "./TypeChecking/Statements.ag" #-} [] {-# LINE 4760 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 99, column 9) _x2OlibUpdates = {-# LINE 99 "./TypeChecking/Statements.ag" #-} [] {-# LINE 4765 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} (_x1IannotatedTree,_x2IannotatedTree) {-# LINE 4770 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} (_x1IoriginalTree,_x2IoriginalTree) {-# LINE 4775 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 4780 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 4785 "AstInternal.hs" #-} -- copy rule (down) _x1Oenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 4790 "AstInternal.hs" #-} -- copy rule (down) _x1Olib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 4795 "AstInternal.hs" #-} -- copy rule (down) _x2Oenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 4800 "AstInternal.hs" #-} -- copy rule (down) _x2Olib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 4805 "AstInternal.hs" #-} ( _x1IannotatedTree,_x1IliftedColumnName,_x1IoriginalTree) = (x1_ _x1Oenv _x1Olib ) ( _x2IannotatedTree,_x2IoriginalTree,_x2IproducedEnv,_x2IproducedLib) = (x2_ _x2Oenv _x2OenvUpdates _x2Olib _x2OlibUpdates ) in ( _lhsOannotatedTree,_lhsOoriginalTree))) -- ExpressionStatementListPairList ----------------------------- {- visit 0: inherited attributes: env : Environment lib : LocalIdentifierBindings synthesized attributes: annotatedTree : SELF originalTree : SELF alternatives: alternative Cons: child hd : ExpressionStatementListPair child tl : ExpressionStatementListPairList visit 0: local annotatedTree : _ local originalTree : _ alternative Nil: visit 0: local annotatedTree : _ local originalTree : _ -} type ExpressionStatementListPairList = [(ExpressionStatementListPair)] -- cata sem_ExpressionStatementListPairList :: ExpressionStatementListPairList -> T_ExpressionStatementListPairList sem_ExpressionStatementListPairList list = (Prelude.foldr sem_ExpressionStatementListPairList_Cons sem_ExpressionStatementListPairList_Nil (Prelude.map sem_ExpressionStatementListPair list) ) -- semantic domain type T_ExpressionStatementListPairList = Environment -> LocalIdentifierBindings -> ( ExpressionStatementListPairList,ExpressionStatementListPairList) data Inh_ExpressionStatementListPairList = Inh_ExpressionStatementListPairList {env_Inh_ExpressionStatementListPairList :: Environment,lib_Inh_ExpressionStatementListPairList :: LocalIdentifierBindings} data Syn_ExpressionStatementListPairList = Syn_ExpressionStatementListPairList {annotatedTree_Syn_ExpressionStatementListPairList :: ExpressionStatementListPairList,originalTree_Syn_ExpressionStatementListPairList :: ExpressionStatementListPairList} wrap_ExpressionStatementListPairList :: T_ExpressionStatementListPairList -> Inh_ExpressionStatementListPairList -> Syn_ExpressionStatementListPairList wrap_ExpressionStatementListPairList sem (Inh_ExpressionStatementListPairList _lhsIenv _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIenv _lhsIlib ) in (Syn_ExpressionStatementListPairList _lhsOannotatedTree _lhsOoriginalTree )) sem_ExpressionStatementListPairList_Cons :: T_ExpressionStatementListPair -> T_ExpressionStatementListPairList -> T_ExpressionStatementListPairList sem_ExpressionStatementListPairList_Cons hd_ tl_ = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: ExpressionStatementListPairList _lhsOoriginalTree :: ExpressionStatementListPairList _hdOenv :: Environment _hdOlib :: LocalIdentifierBindings _tlOenv :: Environment _tlOlib :: LocalIdentifierBindings _hdIannotatedTree :: ExpressionStatementListPair _hdIoriginalTree :: ExpressionStatementListPair _tlIannotatedTree :: ExpressionStatementListPairList _tlIoriginalTree :: ExpressionStatementListPairList -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} (:) _hdIannotatedTree _tlIannotatedTree {-# LINE 4871 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} (:) _hdIoriginalTree _tlIoriginalTree {-# LINE 4876 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 4881 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 4886 "AstInternal.hs" #-} -- copy rule (down) _hdOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 4891 "AstInternal.hs" #-} -- copy rule (down) _hdOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 4896 "AstInternal.hs" #-} -- copy rule (down) _tlOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 4901 "AstInternal.hs" #-} -- copy rule (down) _tlOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 4906 "AstInternal.hs" #-} ( _hdIannotatedTree,_hdIoriginalTree) = (hd_ _hdOenv _hdOlib ) ( _tlIannotatedTree,_tlIoriginalTree) = (tl_ _tlOenv _tlOlib ) in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_ExpressionStatementListPairList_Nil :: T_ExpressionStatementListPairList sem_ExpressionStatementListPairList_Nil = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: ExpressionStatementListPairList _lhsOoriginalTree :: ExpressionStatementListPairList -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 4922 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 4927 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 4932 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 4937 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) -- FnBody ------------------------------------------------------ {- visit 0: inherited attributes: env : Environment lib : LocalIdentifierBindings synthesized attributes: annotatedTree : SELF originalTree : SELF alternatives: alternative PlpgsqlFnBody: child ann : {Annotation} child vars : VarDefList child sts : StatementList visit 0: local annotatedTree : _ local originalTree : _ alternative SqlFnBody: child ann : {Annotation} child sts : StatementList visit 0: local annotatedTree : _ local originalTree : _ -} data FnBody = PlpgsqlFnBody (Annotation) (VarDefList) (StatementList) | SqlFnBody (Annotation) (StatementList) deriving ( Data,Eq,Show,Typeable) -- cata sem_FnBody :: FnBody -> T_FnBody sem_FnBody (PlpgsqlFnBody _ann _vars _sts ) = (sem_FnBody_PlpgsqlFnBody _ann (sem_VarDefList _vars ) (sem_StatementList _sts ) ) sem_FnBody (SqlFnBody _ann _sts ) = (sem_FnBody_SqlFnBody _ann (sem_StatementList _sts ) ) -- semantic domain type T_FnBody = Environment -> LocalIdentifierBindings -> ( FnBody,FnBody) data Inh_FnBody = Inh_FnBody {env_Inh_FnBody :: Environment,lib_Inh_FnBody :: LocalIdentifierBindings} data Syn_FnBody = Syn_FnBody {annotatedTree_Syn_FnBody :: FnBody,originalTree_Syn_FnBody :: FnBody} wrap_FnBody :: T_FnBody -> Inh_FnBody -> Syn_FnBody wrap_FnBody sem (Inh_FnBody _lhsIenv _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIenv _lhsIlib ) in (Syn_FnBody _lhsOannotatedTree _lhsOoriginalTree )) sem_FnBody_PlpgsqlFnBody :: Annotation -> T_VarDefList -> T_StatementList -> T_FnBody sem_FnBody_PlpgsqlFnBody ann_ vars_ sts_ = (\ _lhsIenv _lhsIlib -> (let _stsOenvUpdates :: ([EnvironmentUpdate]) _stsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _stsOlib :: LocalIdentifierBindings _lhsOannotatedTree :: FnBody _lhsOoriginalTree :: FnBody _varsOenv :: Environment _varsOlib :: LocalIdentifierBindings _stsOenv :: Environment _varsIannotatedTree :: VarDefList _varsIdefs :: ([(String,Type)]) _varsIoriginalTree :: VarDefList _stsIannotatedTree :: StatementList _stsIoriginalTree :: StatementList _stsIproducedEnv :: Environment _stsIproducedLib :: LocalIdentifierBindings -- "./TypeChecking/Statements.ag"(line 102, column 9) _stsOenvUpdates = {-# LINE 102 "./TypeChecking/Statements.ag" #-} [] {-# LINE 5012 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 103, column 9) _stsOlibUpdates = {-# LINE 103 "./TypeChecking/Statements.ag" #-} [] {-# LINE 5017 "AstInternal.hs" #-} -- "./TypeChecking/CreateFunction.ag"(line 121, column 9) _stsOlib = {-# LINE 121 "./TypeChecking/CreateFunction.ag" #-} fromRight _lhsIlib $ updateBindings _lhsIlib _lhsIenv [LibStackIDs [("", _varsIdefs)]] {-# LINE 5024 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} PlpgsqlFnBody ann_ _varsIannotatedTree _stsIannotatedTree {-# LINE 5029 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} PlpgsqlFnBody ann_ _varsIoriginalTree _stsIoriginalTree {-# LINE 5034 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 5039 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 5044 "AstInternal.hs" #-} -- copy rule (down) _varsOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 5049 "AstInternal.hs" #-} -- copy rule (down) _varsOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 5054 "AstInternal.hs" #-} -- copy rule (down) _stsOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 5059 "AstInternal.hs" #-} ( _varsIannotatedTree,_varsIdefs,_varsIoriginalTree) = (vars_ _varsOenv _varsOlib ) ( _stsIannotatedTree,_stsIoriginalTree,_stsIproducedEnv,_stsIproducedLib) = (sts_ _stsOenv _stsOenvUpdates _stsOlib _stsOlibUpdates ) in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_FnBody_SqlFnBody :: Annotation -> T_StatementList -> T_FnBody sem_FnBody_SqlFnBody ann_ sts_ = (\ _lhsIenv _lhsIlib -> (let _stsOenvUpdates :: ([EnvironmentUpdate]) _stsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _lhsOannotatedTree :: FnBody _lhsOoriginalTree :: FnBody _stsOenv :: Environment _stsOlib :: LocalIdentifierBindings _stsIannotatedTree :: StatementList _stsIoriginalTree :: StatementList _stsIproducedEnv :: Environment _stsIproducedLib :: LocalIdentifierBindings -- "./TypeChecking/Statements.ag"(line 102, column 9) _stsOenvUpdates = {-# LINE 102 "./TypeChecking/Statements.ag" #-} [] {-# LINE 5085 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 103, column 9) _stsOlibUpdates = {-# LINE 103 "./TypeChecking/Statements.ag" #-} [] {-# LINE 5090 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} SqlFnBody ann_ _stsIannotatedTree {-# LINE 5095 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} SqlFnBody ann_ _stsIoriginalTree {-# LINE 5100 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 5105 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 5110 "AstInternal.hs" #-} -- copy rule (down) _stsOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 5115 "AstInternal.hs" #-} -- copy rule (down) _stsOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 5120 "AstInternal.hs" #-} ( _stsIannotatedTree,_stsIoriginalTree,_stsIproducedEnv,_stsIproducedLib) = (sts_ _stsOenv _stsOenvUpdates _stsOlib _stsOlibUpdates ) in ( _lhsOannotatedTree,_lhsOoriginalTree))) -- FrameClause ------------------------------------------------- {- visit 0: inherited attributes: env : Environment lib : LocalIdentifierBindings synthesized attributes: annotatedTree : SELF originalTree : SELF alternatives: alternative FrameRowsUnboundedPreceding: visit 0: local annotatedTree : _ local originalTree : _ alternative FrameUnboundedFull: visit 0: local annotatedTree : _ local originalTree : _ alternative FrameUnboundedPreceding: visit 0: local annotatedTree : _ local originalTree : _ -} data FrameClause = FrameRowsUnboundedPreceding | FrameUnboundedFull | FrameUnboundedPreceding deriving ( Data,Eq,Show,Typeable) -- cata sem_FrameClause :: FrameClause -> T_FrameClause sem_FrameClause (FrameRowsUnboundedPreceding ) = (sem_FrameClause_FrameRowsUnboundedPreceding ) sem_FrameClause (FrameUnboundedFull ) = (sem_FrameClause_FrameUnboundedFull ) sem_FrameClause (FrameUnboundedPreceding ) = (sem_FrameClause_FrameUnboundedPreceding ) -- semantic domain type T_FrameClause = Environment -> LocalIdentifierBindings -> ( FrameClause,FrameClause) data Inh_FrameClause = Inh_FrameClause {env_Inh_FrameClause :: Environment,lib_Inh_FrameClause :: LocalIdentifierBindings} data Syn_FrameClause = Syn_FrameClause {annotatedTree_Syn_FrameClause :: FrameClause,originalTree_Syn_FrameClause :: FrameClause} wrap_FrameClause :: T_FrameClause -> Inh_FrameClause -> Syn_FrameClause wrap_FrameClause sem (Inh_FrameClause _lhsIenv _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIenv _lhsIlib ) in (Syn_FrameClause _lhsOannotatedTree _lhsOoriginalTree )) sem_FrameClause_FrameRowsUnboundedPreceding :: T_FrameClause sem_FrameClause_FrameRowsUnboundedPreceding = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: FrameClause _lhsOoriginalTree :: FrameClause -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} FrameRowsUnboundedPreceding {-# LINE 5183 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} FrameRowsUnboundedPreceding {-# LINE 5188 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 5193 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 5198 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_FrameClause_FrameUnboundedFull :: T_FrameClause sem_FrameClause_FrameUnboundedFull = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: FrameClause _lhsOoriginalTree :: FrameClause -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} FrameUnboundedFull {-# LINE 5210 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} FrameUnboundedFull {-# LINE 5215 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 5220 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 5225 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_FrameClause_FrameUnboundedPreceding :: T_FrameClause sem_FrameClause_FrameUnboundedPreceding = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: FrameClause _lhsOoriginalTree :: FrameClause -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} FrameUnboundedPreceding {-# LINE 5237 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} FrameUnboundedPreceding {-# LINE 5242 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 5247 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 5252 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) -- IfExists ---------------------------------------------------- {- visit 0: inherited attributes: env : Environment lib : LocalIdentifierBindings synthesized attributes: annotatedTree : SELF originalTree : SELF alternatives: alternative IfExists: visit 0: local annotatedTree : _ local originalTree : _ alternative Require: visit 0: local annotatedTree : _ local originalTree : _ -} data IfExists = IfExists | Require deriving ( Data,Eq,Show,Typeable) -- cata sem_IfExists :: IfExists -> T_IfExists sem_IfExists (IfExists ) = (sem_IfExists_IfExists ) sem_IfExists (Require ) = (sem_IfExists_Require ) -- semantic domain type T_IfExists = Environment -> LocalIdentifierBindings -> ( IfExists,IfExists) data Inh_IfExists = Inh_IfExists {env_Inh_IfExists :: Environment,lib_Inh_IfExists :: LocalIdentifierBindings} data Syn_IfExists = Syn_IfExists {annotatedTree_Syn_IfExists :: IfExists,originalTree_Syn_IfExists :: IfExists} wrap_IfExists :: T_IfExists -> Inh_IfExists -> Syn_IfExists wrap_IfExists sem (Inh_IfExists _lhsIenv _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIenv _lhsIlib ) in (Syn_IfExists _lhsOannotatedTree _lhsOoriginalTree )) sem_IfExists_IfExists :: T_IfExists sem_IfExists_IfExists = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: IfExists _lhsOoriginalTree :: IfExists -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} IfExists {-# LINE 5306 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} IfExists {-# LINE 5311 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 5316 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 5321 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_IfExists_Require :: T_IfExists sem_IfExists_Require = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: IfExists _lhsOoriginalTree :: IfExists -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Require {-# LINE 5333 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Require {-# LINE 5338 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 5343 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 5348 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) -- InList ------------------------------------------------------ {- visit 0: inherited attributes: env : Environment lib : LocalIdentifierBindings synthesized attributes: annotatedTree : SELF listType : Either [TypeError] Type originalTree : SELF alternatives: alternative InList: child ann : {Annotation} child exprs : ExpressionList visit 0: local annotatedTree : _ local originalTree : _ alternative InSelect: child ann : {Annotation} child sel : SelectExpression visit 0: local annotatedTree : _ local originalTree : _ -} data InList = InList (Annotation) (ExpressionList) | InSelect (Annotation) (SelectExpression) deriving ( Data,Eq,Show,Typeable) -- cata sem_InList :: InList -> T_InList sem_InList (InList _ann _exprs ) = (sem_InList_InList _ann (sem_ExpressionList _exprs ) ) sem_InList (InSelect _ann _sel ) = (sem_InList_InSelect _ann (sem_SelectExpression _sel ) ) -- semantic domain type T_InList = Environment -> LocalIdentifierBindings -> ( InList,(Either [TypeError] Type),InList) data Inh_InList = Inh_InList {env_Inh_InList :: Environment,lib_Inh_InList :: LocalIdentifierBindings} data Syn_InList = Syn_InList {annotatedTree_Syn_InList :: InList,listType_Syn_InList :: Either [TypeError] Type,originalTree_Syn_InList :: InList} wrap_InList :: T_InList -> Inh_InList -> Syn_InList wrap_InList sem (Inh_InList _lhsIenv _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOlistType,_lhsOoriginalTree) = (sem _lhsIenv _lhsIlib ) in (Syn_InList _lhsOannotatedTree _lhsOlistType _lhsOoriginalTree )) sem_InList_InList :: Annotation -> T_ExpressionList -> T_InList sem_InList_InList ann_ exprs_ = (\ _lhsIenv _lhsIlib -> (let _lhsOlistType :: (Either [TypeError] Type) _lhsOannotatedTree :: InList _lhsOoriginalTree :: InList _exprsOenv :: Environment _exprsOlib :: LocalIdentifierBindings _exprsIannotatedTree :: ExpressionList _exprsIoriginalTree :: ExpressionList _exprsItypeList :: ([Type]) -- "./TypeChecking/Expressions.ag"(line 299, column 9) _lhsOlistType = {-# LINE 299 "./TypeChecking/Expressions.ag" #-} resolveResultSetType _lhsIenv _exprsItypeList {-# LINE 5415 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} InList ann_ _exprsIannotatedTree {-# LINE 5420 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} InList ann_ _exprsIoriginalTree {-# LINE 5425 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 5430 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 5435 "AstInternal.hs" #-} -- copy rule (down) _exprsOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 5440 "AstInternal.hs" #-} -- copy rule (down) _exprsOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 5445 "AstInternal.hs" #-} ( _exprsIannotatedTree,_exprsIoriginalTree,_exprsItypeList) = (exprs_ _exprsOenv _exprsOlib ) in ( _lhsOannotatedTree,_lhsOlistType,_lhsOoriginalTree))) sem_InList_InSelect :: Annotation -> T_SelectExpression -> T_InList sem_InList_InSelect ann_ sel_ = (\ _lhsIenv _lhsIlib -> (let _lhsOlistType :: (Either [TypeError] Type) _lhsOannotatedTree :: InList _lhsOoriginalTree :: InList _selOenv :: Environment _selOlib :: LocalIdentifierBindings _selIannotatedTree :: SelectExpression _selIlibUpdates :: ([LocalIdentifierBindingsUpdate]) _selIoriginalTree :: SelectExpression -- "./TypeChecking/Expressions.ag"(line 301, column 9) _lhsOlistType = {-# LINE 301 "./TypeChecking/Expressions.ag" #-} do attrs <- map snd <$> (unwrapSetOfComposite $ getTypeAnnotation _selIannotatedTree) typ <- case length attrs of 0 -> Left [InternalError "got subquery with no columns? in inselect"] 1 -> Right $ head attrs _ -> Right $ AnonymousRecordType attrs dependsOnRTpe attrs $ Right typ {-# LINE 5475 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} InSelect ann_ _selIannotatedTree {-# LINE 5480 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} InSelect ann_ _selIoriginalTree {-# LINE 5485 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 5490 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 5495 "AstInternal.hs" #-} -- copy rule (down) _selOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 5500 "AstInternal.hs" #-} -- copy rule (down) _selOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 5505 "AstInternal.hs" #-} ( _selIannotatedTree,_selIlibUpdates,_selIoriginalTree) = (sel_ _selOenv _selOlib ) in ( _lhsOannotatedTree,_lhsOlistType,_lhsOoriginalTree))) -- JoinExpression ---------------------------------------------- {- visit 0: inherited attributes: env : Environment lib : LocalIdentifierBindings synthesized attributes: annotatedTree : SELF originalTree : SELF alternatives: alternative JoinOn: child ann : {Annotation} child expression : Expression visit 0: local annotatedTree : _ local originalTree : _ alternative JoinUsing: child ann : {Annotation} child stringList : StringList visit 0: local annotatedTree : _ local originalTree : _ -} data JoinExpression = JoinOn (Annotation) (Expression) | JoinUsing (Annotation) (StringList) deriving ( Data,Eq,Show,Typeable) -- cata sem_JoinExpression :: JoinExpression -> T_JoinExpression sem_JoinExpression (JoinOn _ann _expression ) = (sem_JoinExpression_JoinOn _ann (sem_Expression _expression ) ) sem_JoinExpression (JoinUsing _ann _stringList ) = (sem_JoinExpression_JoinUsing _ann (sem_StringList _stringList ) ) -- semantic domain type T_JoinExpression = Environment -> LocalIdentifierBindings -> ( JoinExpression,JoinExpression) data Inh_JoinExpression = Inh_JoinExpression {env_Inh_JoinExpression :: Environment,lib_Inh_JoinExpression :: LocalIdentifierBindings} data Syn_JoinExpression = Syn_JoinExpression {annotatedTree_Syn_JoinExpression :: JoinExpression,originalTree_Syn_JoinExpression :: JoinExpression} wrap_JoinExpression :: T_JoinExpression -> Inh_JoinExpression -> Syn_JoinExpression wrap_JoinExpression sem (Inh_JoinExpression _lhsIenv _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIenv _lhsIlib ) in (Syn_JoinExpression _lhsOannotatedTree _lhsOoriginalTree )) sem_JoinExpression_JoinOn :: Annotation -> T_Expression -> T_JoinExpression sem_JoinExpression_JoinOn ann_ expression_ = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: JoinExpression _lhsOoriginalTree :: JoinExpression _expressionOenv :: Environment _expressionOlib :: LocalIdentifierBindings _expressionIannotatedTree :: Expression _expressionIliftedColumnName :: String _expressionIoriginalTree :: Expression -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} JoinOn ann_ _expressionIannotatedTree {-# LINE 5572 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} JoinOn ann_ _expressionIoriginalTree {-# LINE 5577 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 5582 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 5587 "AstInternal.hs" #-} -- copy rule (down) _expressionOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 5592 "AstInternal.hs" #-} -- copy rule (down) _expressionOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 5597 "AstInternal.hs" #-} ( _expressionIannotatedTree,_expressionIliftedColumnName,_expressionIoriginalTree) = (expression_ _expressionOenv _expressionOlib ) in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_JoinExpression_JoinUsing :: Annotation -> T_StringList -> T_JoinExpression sem_JoinExpression_JoinUsing ann_ stringList_ = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: JoinExpression _lhsOoriginalTree :: JoinExpression _stringListOenv :: Environment _stringListOlib :: LocalIdentifierBindings _stringListIannotatedTree :: StringList _stringListIoriginalTree :: StringList _stringListIstrings :: ([String]) -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} JoinUsing ann_ _stringListIannotatedTree {-# LINE 5618 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} JoinUsing ann_ _stringListIoriginalTree {-# LINE 5623 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 5628 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 5633 "AstInternal.hs" #-} -- copy rule (down) _stringListOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 5638 "AstInternal.hs" #-} -- copy rule (down) _stringListOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 5643 "AstInternal.hs" #-} ( _stringListIannotatedTree,_stringListIoriginalTree,_stringListIstrings) = (stringList_ _stringListOenv _stringListOlib ) in ( _lhsOannotatedTree,_lhsOoriginalTree))) -- JoinType ---------------------------------------------------- {- visit 0: inherited attributes: env : Environment lib : LocalIdentifierBindings synthesized attributes: annotatedTree : SELF originalTree : SELF alternatives: alternative Cross: visit 0: local annotatedTree : _ local originalTree : _ alternative FullOuter: visit 0: local annotatedTree : _ local originalTree : _ alternative Inner: visit 0: local annotatedTree : _ local originalTree : _ alternative LeftOuter: visit 0: local annotatedTree : _ local originalTree : _ alternative RightOuter: visit 0: local annotatedTree : _ local originalTree : _ -} data JoinType = Cross | FullOuter | Inner | LeftOuter | RightOuter deriving ( Data,Eq,Show,Typeable) -- cata sem_JoinType :: JoinType -> T_JoinType sem_JoinType (Cross ) = (sem_JoinType_Cross ) sem_JoinType (FullOuter ) = (sem_JoinType_FullOuter ) sem_JoinType (Inner ) = (sem_JoinType_Inner ) sem_JoinType (LeftOuter ) = (sem_JoinType_LeftOuter ) sem_JoinType (RightOuter ) = (sem_JoinType_RightOuter ) -- semantic domain type T_JoinType = Environment -> LocalIdentifierBindings -> ( JoinType,JoinType) data Inh_JoinType = Inh_JoinType {env_Inh_JoinType :: Environment,lib_Inh_JoinType :: LocalIdentifierBindings} data Syn_JoinType = Syn_JoinType {annotatedTree_Syn_JoinType :: JoinType,originalTree_Syn_JoinType :: JoinType} wrap_JoinType :: T_JoinType -> Inh_JoinType -> Syn_JoinType wrap_JoinType sem (Inh_JoinType _lhsIenv _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIenv _lhsIlib ) in (Syn_JoinType _lhsOannotatedTree _lhsOoriginalTree )) sem_JoinType_Cross :: T_JoinType sem_JoinType_Cross = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: JoinType _lhsOoriginalTree :: JoinType -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Cross {-# LINE 5720 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Cross {-# LINE 5725 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 5730 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 5735 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_JoinType_FullOuter :: T_JoinType sem_JoinType_FullOuter = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: JoinType _lhsOoriginalTree :: JoinType -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} FullOuter {-# LINE 5747 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} FullOuter {-# LINE 5752 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 5757 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 5762 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_JoinType_Inner :: T_JoinType sem_JoinType_Inner = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: JoinType _lhsOoriginalTree :: JoinType -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Inner {-# LINE 5774 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Inner {-# LINE 5779 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 5784 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 5789 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_JoinType_LeftOuter :: T_JoinType sem_JoinType_LeftOuter = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: JoinType _lhsOoriginalTree :: JoinType -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} LeftOuter {-# LINE 5801 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} LeftOuter {-# LINE 5806 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 5811 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 5816 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_JoinType_RightOuter :: T_JoinType sem_JoinType_RightOuter = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: JoinType _lhsOoriginalTree :: JoinType -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} RightOuter {-# LINE 5828 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} RightOuter {-# LINE 5833 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 5838 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 5843 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) -- Language ---------------------------------------------------- {- visit 0: inherited attributes: env : Environment lib : LocalIdentifierBindings synthesized attributes: annotatedTree : SELF originalTree : SELF alternatives: alternative Plpgsql: visit 0: local annotatedTree : _ local originalTree : _ alternative Sql: visit 0: local annotatedTree : _ local originalTree : _ -} data Language = Plpgsql | Sql deriving ( Data,Eq,Show,Typeable) -- cata sem_Language :: Language -> T_Language sem_Language (Plpgsql ) = (sem_Language_Plpgsql ) sem_Language (Sql ) = (sem_Language_Sql ) -- semantic domain type T_Language = Environment -> LocalIdentifierBindings -> ( Language,Language) data Inh_Language = Inh_Language {env_Inh_Language :: Environment,lib_Inh_Language :: LocalIdentifierBindings} data Syn_Language = Syn_Language {annotatedTree_Syn_Language :: Language,originalTree_Syn_Language :: Language} wrap_Language :: T_Language -> Inh_Language -> Syn_Language wrap_Language sem (Inh_Language _lhsIenv _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIenv _lhsIlib ) in (Syn_Language _lhsOannotatedTree _lhsOoriginalTree )) sem_Language_Plpgsql :: T_Language sem_Language_Plpgsql = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: Language _lhsOoriginalTree :: Language -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Plpgsql {-# LINE 5897 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Plpgsql {-# LINE 5902 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 5907 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 5912 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_Language_Sql :: T_Language sem_Language_Sql = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: Language _lhsOoriginalTree :: Language -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Sql {-# LINE 5924 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Sql {-# LINE 5929 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 5934 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 5939 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) -- LiftFlavour ------------------------------------------------- {- visit 0: inherited attributes: env : Environment lib : LocalIdentifierBindings synthesized attributes: annotatedTree : SELF originalTree : SELF alternatives: alternative LiftAll: visit 0: local annotatedTree : _ local originalTree : _ alternative LiftAny: visit 0: local annotatedTree : _ local originalTree : _ -} data LiftFlavour = LiftAll | LiftAny deriving ( Data,Eq,Show,Typeable) -- cata sem_LiftFlavour :: LiftFlavour -> T_LiftFlavour sem_LiftFlavour (LiftAll ) = (sem_LiftFlavour_LiftAll ) sem_LiftFlavour (LiftAny ) = (sem_LiftFlavour_LiftAny ) -- semantic domain type T_LiftFlavour = Environment -> LocalIdentifierBindings -> ( LiftFlavour,LiftFlavour) data Inh_LiftFlavour = Inh_LiftFlavour {env_Inh_LiftFlavour :: Environment,lib_Inh_LiftFlavour :: LocalIdentifierBindings} data Syn_LiftFlavour = Syn_LiftFlavour {annotatedTree_Syn_LiftFlavour :: LiftFlavour,originalTree_Syn_LiftFlavour :: LiftFlavour} wrap_LiftFlavour :: T_LiftFlavour -> Inh_LiftFlavour -> Syn_LiftFlavour wrap_LiftFlavour sem (Inh_LiftFlavour _lhsIenv _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIenv _lhsIlib ) in (Syn_LiftFlavour _lhsOannotatedTree _lhsOoriginalTree )) sem_LiftFlavour_LiftAll :: T_LiftFlavour sem_LiftFlavour_LiftAll = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: LiftFlavour _lhsOoriginalTree :: LiftFlavour -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} LiftAll {-# LINE 5993 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} LiftAll {-# LINE 5998 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 6003 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 6008 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_LiftFlavour_LiftAny :: T_LiftFlavour sem_LiftFlavour_LiftAny = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: LiftFlavour _lhsOoriginalTree :: LiftFlavour -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} LiftAny {-# LINE 6020 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} LiftAny {-# LINE 6025 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 6030 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 6035 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) -- MaybeBoolExpression ----------------------------------------- {- visit 0: inherited attributes: env : Environment lib : LocalIdentifierBindings synthesized attributes: annotatedTree : SELF originalTree : SELF alternatives: alternative Just: child just : Expression visit 0: local annotatedTree : _ local originalTree : _ alternative Nothing: visit 0: local annotatedTree : _ local originalTree : _ -} type MaybeBoolExpression = (Maybe (Expression)) -- cata sem_MaybeBoolExpression :: MaybeBoolExpression -> T_MaybeBoolExpression sem_MaybeBoolExpression (Prelude.Just x ) = (sem_MaybeBoolExpression_Just (sem_Expression x ) ) sem_MaybeBoolExpression Prelude.Nothing = sem_MaybeBoolExpression_Nothing -- semantic domain type T_MaybeBoolExpression = Environment -> LocalIdentifierBindings -> ( MaybeBoolExpression,MaybeBoolExpression) data Inh_MaybeBoolExpression = Inh_MaybeBoolExpression {env_Inh_MaybeBoolExpression :: Environment,lib_Inh_MaybeBoolExpression :: LocalIdentifierBindings} data Syn_MaybeBoolExpression = Syn_MaybeBoolExpression {annotatedTree_Syn_MaybeBoolExpression :: MaybeBoolExpression,originalTree_Syn_MaybeBoolExpression :: MaybeBoolExpression} wrap_MaybeBoolExpression :: T_MaybeBoolExpression -> Inh_MaybeBoolExpression -> Syn_MaybeBoolExpression wrap_MaybeBoolExpression sem (Inh_MaybeBoolExpression _lhsIenv _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIenv _lhsIlib ) in (Syn_MaybeBoolExpression _lhsOannotatedTree _lhsOoriginalTree )) sem_MaybeBoolExpression_Just :: T_Expression -> T_MaybeBoolExpression sem_MaybeBoolExpression_Just just_ = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: MaybeBoolExpression _lhsOoriginalTree :: MaybeBoolExpression _justOenv :: Environment _justOlib :: LocalIdentifierBindings _justIannotatedTree :: Expression _justIliftedColumnName :: String _justIoriginalTree :: Expression -- "./TypeChecking/Misc.ag"(line 74, column 9) _lhsOannotatedTree = {-# LINE 74 "./TypeChecking/Misc.ag" #-} if getTypeAnnotation _justIannotatedTree `notElem` [typeBool, TypeCheckFailed] then Just $ updateAnnotation ((TypeErrorA ExpressionMustBeBool) :) _justIannotatedTree else Just $ _justIannotatedTree {-# LINE 6097 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Just _justIannotatedTree {-# LINE 6102 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Just _justIoriginalTree {-# LINE 6107 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 6112 "AstInternal.hs" #-} -- copy rule (down) _justOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 6117 "AstInternal.hs" #-} -- copy rule (down) _justOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 6122 "AstInternal.hs" #-} ( _justIannotatedTree,_justIliftedColumnName,_justIoriginalTree) = (just_ _justOenv _justOlib ) in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_MaybeBoolExpression_Nothing :: T_MaybeBoolExpression sem_MaybeBoolExpression_Nothing = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: MaybeBoolExpression _lhsOoriginalTree :: MaybeBoolExpression -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Nothing {-# LINE 6136 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Nothing {-# LINE 6141 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 6146 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 6151 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) -- MaybeExpression --------------------------------------------- {- visit 0: inherited attributes: env : Environment lib : LocalIdentifierBindings synthesized attributes: annotatedTree : SELF originalTree : SELF alternatives: alternative Just: child just : Expression visit 0: local annotatedTree : _ local originalTree : _ alternative Nothing: visit 0: local annotatedTree : _ local originalTree : _ -} type MaybeExpression = (Maybe (Expression)) -- cata sem_MaybeExpression :: MaybeExpression -> T_MaybeExpression sem_MaybeExpression (Prelude.Just x ) = (sem_MaybeExpression_Just (sem_Expression x ) ) sem_MaybeExpression Prelude.Nothing = sem_MaybeExpression_Nothing -- semantic domain type T_MaybeExpression = Environment -> LocalIdentifierBindings -> ( MaybeExpression,MaybeExpression) data Inh_MaybeExpression = Inh_MaybeExpression {env_Inh_MaybeExpression :: Environment,lib_Inh_MaybeExpression :: LocalIdentifierBindings} data Syn_MaybeExpression = Syn_MaybeExpression {annotatedTree_Syn_MaybeExpression :: MaybeExpression,originalTree_Syn_MaybeExpression :: MaybeExpression} wrap_MaybeExpression :: T_MaybeExpression -> Inh_MaybeExpression -> Syn_MaybeExpression wrap_MaybeExpression sem (Inh_MaybeExpression _lhsIenv _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIenv _lhsIlib ) in (Syn_MaybeExpression _lhsOannotatedTree _lhsOoriginalTree )) sem_MaybeExpression_Just :: T_Expression -> T_MaybeExpression sem_MaybeExpression_Just just_ = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: MaybeExpression _lhsOoriginalTree :: MaybeExpression _justOenv :: Environment _justOlib :: LocalIdentifierBindings _justIannotatedTree :: Expression _justIliftedColumnName :: String _justIoriginalTree :: Expression -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Just _justIannotatedTree {-# LINE 6210 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Just _justIoriginalTree {-# LINE 6215 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 6220 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 6225 "AstInternal.hs" #-} -- copy rule (down) _justOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 6230 "AstInternal.hs" #-} -- copy rule (down) _justOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 6235 "AstInternal.hs" #-} ( _justIannotatedTree,_justIliftedColumnName,_justIoriginalTree) = (just_ _justOenv _justOlib ) in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_MaybeExpression_Nothing :: T_MaybeExpression sem_MaybeExpression_Nothing = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: MaybeExpression _lhsOoriginalTree :: MaybeExpression -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Nothing {-# LINE 6249 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Nothing {-# LINE 6254 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 6259 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 6264 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) -- MaybeSelectList --------------------------------------------- {- visit 0: inherited attributes: env : Environment lib : LocalIdentifierBindings synthesized attributes: annotatedTree : SELF listType : Maybe [(String,Type)] originalTree : SELF alternatives: alternative Just: child just : SelectList visit 0: local annotatedTree : _ local originalTree : _ alternative Nothing: visit 0: local annotatedTree : _ local originalTree : _ -} type MaybeSelectList = (Maybe (SelectList)) -- cata sem_MaybeSelectList :: MaybeSelectList -> T_MaybeSelectList sem_MaybeSelectList (Prelude.Just x ) = (sem_MaybeSelectList_Just (sem_SelectList x ) ) sem_MaybeSelectList Prelude.Nothing = sem_MaybeSelectList_Nothing -- semantic domain type T_MaybeSelectList = Environment -> LocalIdentifierBindings -> ( MaybeSelectList,(Maybe [(String,Type)]),MaybeSelectList) data Inh_MaybeSelectList = Inh_MaybeSelectList {env_Inh_MaybeSelectList :: Environment,lib_Inh_MaybeSelectList :: LocalIdentifierBindings} data Syn_MaybeSelectList = Syn_MaybeSelectList {annotatedTree_Syn_MaybeSelectList :: MaybeSelectList,listType_Syn_MaybeSelectList :: Maybe [(String,Type)],originalTree_Syn_MaybeSelectList :: MaybeSelectList} wrap_MaybeSelectList :: T_MaybeSelectList -> Inh_MaybeSelectList -> Syn_MaybeSelectList wrap_MaybeSelectList sem (Inh_MaybeSelectList _lhsIenv _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOlistType,_lhsOoriginalTree) = (sem _lhsIenv _lhsIlib ) in (Syn_MaybeSelectList _lhsOannotatedTree _lhsOlistType _lhsOoriginalTree )) sem_MaybeSelectList_Just :: T_SelectList -> T_MaybeSelectList sem_MaybeSelectList_Just just_ = (\ _lhsIenv _lhsIlib -> (let _lhsOlistType :: (Maybe [(String,Type)]) _lhsOannotatedTree :: MaybeSelectList _lhsOoriginalTree :: MaybeSelectList _justOenv :: Environment _justOlib :: LocalIdentifierBindings _justIannotatedTree :: SelectList _justIlibUpdates :: ([LocalIdentifierBindingsUpdate]) _justIlistType :: ([(String,Type)]) _justIoriginalTree :: SelectList -- "./TypeChecking/SelectLists.ag"(line 25, column 12) _lhsOlistType = {-# LINE 25 "./TypeChecking/SelectLists.ag" #-} Just _justIlistType {-# LINE 6326 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Just _justIannotatedTree {-# LINE 6331 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Just _justIoriginalTree {-# LINE 6336 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 6341 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 6346 "AstInternal.hs" #-} -- copy rule (down) _justOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 6351 "AstInternal.hs" #-} -- copy rule (down) _justOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 6356 "AstInternal.hs" #-} ( _justIannotatedTree,_justIlibUpdates,_justIlistType,_justIoriginalTree) = (just_ _justOenv _justOlib ) in ( _lhsOannotatedTree,_lhsOlistType,_lhsOoriginalTree))) sem_MaybeSelectList_Nothing :: T_MaybeSelectList sem_MaybeSelectList_Nothing = (\ _lhsIenv _lhsIlib -> (let _lhsOlistType :: (Maybe [(String,Type)]) _lhsOannotatedTree :: MaybeSelectList _lhsOoriginalTree :: MaybeSelectList -- "./TypeChecking/SelectLists.ag"(line 26, column 15) _lhsOlistType = {-# LINE 26 "./TypeChecking/SelectLists.ag" #-} Nothing {-# LINE 6371 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Nothing {-# LINE 6376 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Nothing {-# LINE 6381 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 6386 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 6391 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOlistType,_lhsOoriginalTree))) -- Natural ----------------------------------------------------- {- visit 0: inherited attributes: env : Environment lib : LocalIdentifierBindings synthesized attributes: annotatedTree : SELF originalTree : SELF alternatives: alternative Natural: visit 0: local annotatedTree : _ local originalTree : _ alternative Unnatural: visit 0: local annotatedTree : _ local originalTree : _ -} data Natural = Natural | Unnatural deriving ( Data,Eq,Show,Typeable) -- cata sem_Natural :: Natural -> T_Natural sem_Natural (Natural ) = (sem_Natural_Natural ) sem_Natural (Unnatural ) = (sem_Natural_Unnatural ) -- semantic domain type T_Natural = Environment -> LocalIdentifierBindings -> ( Natural,Natural) data Inh_Natural = Inh_Natural {env_Inh_Natural :: Environment,lib_Inh_Natural :: LocalIdentifierBindings} data Syn_Natural = Syn_Natural {annotatedTree_Syn_Natural :: Natural,originalTree_Syn_Natural :: Natural} wrap_Natural :: T_Natural -> Inh_Natural -> Syn_Natural wrap_Natural sem (Inh_Natural _lhsIenv _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIenv _lhsIlib ) in (Syn_Natural _lhsOannotatedTree _lhsOoriginalTree )) sem_Natural_Natural :: T_Natural sem_Natural_Natural = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: Natural _lhsOoriginalTree :: Natural -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Natural {-# LINE 6445 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Natural {-# LINE 6450 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 6455 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 6460 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_Natural_Unnatural :: T_Natural sem_Natural_Unnatural = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: Natural _lhsOoriginalTree :: Natural -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Unnatural {-# LINE 6472 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Unnatural {-# LINE 6477 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 6482 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 6487 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) -- OnExpr ------------------------------------------------------ {- visit 0: inherited attributes: env : Environment lib : LocalIdentifierBindings synthesized attributes: annotatedTree : SELF originalTree : SELF alternatives: alternative Just: child just : JoinExpression visit 0: local annotatedTree : _ local originalTree : _ alternative Nothing: visit 0: local annotatedTree : _ local originalTree : _ -} type OnExpr = (Maybe (JoinExpression)) -- cata sem_OnExpr :: OnExpr -> T_OnExpr sem_OnExpr (Prelude.Just x ) = (sem_OnExpr_Just (sem_JoinExpression x ) ) sem_OnExpr Prelude.Nothing = sem_OnExpr_Nothing -- semantic domain type T_OnExpr = Environment -> LocalIdentifierBindings -> ( OnExpr,OnExpr) data Inh_OnExpr = Inh_OnExpr {env_Inh_OnExpr :: Environment,lib_Inh_OnExpr :: LocalIdentifierBindings} data Syn_OnExpr = Syn_OnExpr {annotatedTree_Syn_OnExpr :: OnExpr,originalTree_Syn_OnExpr :: OnExpr} wrap_OnExpr :: T_OnExpr -> Inh_OnExpr -> Syn_OnExpr wrap_OnExpr sem (Inh_OnExpr _lhsIenv _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIenv _lhsIlib ) in (Syn_OnExpr _lhsOannotatedTree _lhsOoriginalTree )) sem_OnExpr_Just :: T_JoinExpression -> T_OnExpr sem_OnExpr_Just just_ = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: OnExpr _lhsOoriginalTree :: OnExpr _justOenv :: Environment _justOlib :: LocalIdentifierBindings _justIannotatedTree :: JoinExpression _justIoriginalTree :: JoinExpression -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Just _justIannotatedTree {-# LINE 6545 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Just _justIoriginalTree {-# LINE 6550 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 6555 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 6560 "AstInternal.hs" #-} -- copy rule (down) _justOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 6565 "AstInternal.hs" #-} -- copy rule (down) _justOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 6570 "AstInternal.hs" #-} ( _justIannotatedTree,_justIoriginalTree) = (just_ _justOenv _justOlib ) in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_OnExpr_Nothing :: T_OnExpr sem_OnExpr_Nothing = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: OnExpr _lhsOoriginalTree :: OnExpr -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Nothing {-# LINE 6584 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Nothing {-# LINE 6589 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 6594 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 6599 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) -- ParamDef ---------------------------------------------------- {- visit 0: inherited attributes: env : Environment lib : LocalIdentifierBindings synthesized attributes: annotatedTree : SELF namedType : Type originalTree : SELF paramName : String alternatives: alternative ParamDef: child ann : {Annotation} child name : {String} child typ : TypeName visit 0: local annotatedTree : _ local originalTree : _ alternative ParamDefTp: child ann : {Annotation} child typ : TypeName visit 0: local annotatedTree : _ local originalTree : _ -} data ParamDef = ParamDef (Annotation) (String) (TypeName) | ParamDefTp (Annotation) (TypeName) deriving ( Data,Eq,Show,Typeable) -- cata sem_ParamDef :: ParamDef -> T_ParamDef sem_ParamDef (ParamDef _ann _name _typ ) = (sem_ParamDef_ParamDef _ann _name (sem_TypeName _typ ) ) sem_ParamDef (ParamDefTp _ann _typ ) = (sem_ParamDef_ParamDefTp _ann (sem_TypeName _typ ) ) -- semantic domain type T_ParamDef = Environment -> LocalIdentifierBindings -> ( ParamDef,Type,ParamDef,String) data Inh_ParamDef = Inh_ParamDef {env_Inh_ParamDef :: Environment,lib_Inh_ParamDef :: LocalIdentifierBindings} data Syn_ParamDef = Syn_ParamDef {annotatedTree_Syn_ParamDef :: ParamDef,namedType_Syn_ParamDef :: Type,originalTree_Syn_ParamDef :: ParamDef,paramName_Syn_ParamDef :: String} wrap_ParamDef :: T_ParamDef -> Inh_ParamDef -> Syn_ParamDef wrap_ParamDef sem (Inh_ParamDef _lhsIenv _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOnamedType,_lhsOoriginalTree,_lhsOparamName) = (sem _lhsIenv _lhsIlib ) in (Syn_ParamDef _lhsOannotatedTree _lhsOnamedType _lhsOoriginalTree _lhsOparamName )) sem_ParamDef_ParamDef :: Annotation -> String -> T_TypeName -> T_ParamDef sem_ParamDef_ParamDef ann_ name_ typ_ = (\ _lhsIenv _lhsIlib -> (let _lhsOnamedType :: Type _lhsOparamName :: String _lhsOannotatedTree :: ParamDef _lhsOoriginalTree :: ParamDef _typOenv :: Environment _typOlib :: LocalIdentifierBindings _typIannotatedTree :: TypeName _typInamedType :: Type _typIoriginalTree :: TypeName -- "./TypeChecking/CreateFunction.ag"(line 56, column 9) _lhsOnamedType = {-# LINE 56 "./TypeChecking/CreateFunction.ag" #-} _typInamedType {-# LINE 6670 "AstInternal.hs" #-} -- "./TypeChecking/CreateFunction.ag"(line 58, column 9) _lhsOparamName = {-# LINE 58 "./TypeChecking/CreateFunction.ag" #-} name_ {-# LINE 6675 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} ParamDef ann_ name_ _typIannotatedTree {-# LINE 6680 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} ParamDef ann_ name_ _typIoriginalTree {-# LINE 6685 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 6690 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 6695 "AstInternal.hs" #-} -- copy rule (down) _typOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 6700 "AstInternal.hs" #-} -- copy rule (down) _typOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 6705 "AstInternal.hs" #-} ( _typIannotatedTree,_typInamedType,_typIoriginalTree) = (typ_ _typOenv _typOlib ) in ( _lhsOannotatedTree,_lhsOnamedType,_lhsOoriginalTree,_lhsOparamName))) sem_ParamDef_ParamDefTp :: Annotation -> T_TypeName -> T_ParamDef sem_ParamDef_ParamDefTp ann_ typ_ = (\ _lhsIenv _lhsIlib -> (let _lhsOnamedType :: Type _lhsOparamName :: String _lhsOannotatedTree :: ParamDef _lhsOoriginalTree :: ParamDef _typOenv :: Environment _typOlib :: LocalIdentifierBindings _typIannotatedTree :: TypeName _typInamedType :: Type _typIoriginalTree :: TypeName -- "./TypeChecking/CreateFunction.ag"(line 56, column 9) _lhsOnamedType = {-# LINE 56 "./TypeChecking/CreateFunction.ag" #-} _typInamedType {-# LINE 6728 "AstInternal.hs" #-} -- "./TypeChecking/CreateFunction.ag"(line 60, column 9) _lhsOparamName = {-# LINE 60 "./TypeChecking/CreateFunction.ag" #-} "" {-# LINE 6733 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} ParamDefTp ann_ _typIannotatedTree {-# LINE 6738 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} ParamDefTp ann_ _typIoriginalTree {-# LINE 6743 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 6748 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 6753 "AstInternal.hs" #-} -- copy rule (down) _typOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 6758 "AstInternal.hs" #-} -- copy rule (down) _typOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 6763 "AstInternal.hs" #-} ( _typIannotatedTree,_typInamedType,_typIoriginalTree) = (typ_ _typOenv _typOlib ) in ( _lhsOannotatedTree,_lhsOnamedType,_lhsOoriginalTree,_lhsOparamName))) -- ParamDefList ------------------------------------------------ {- visit 0: inherited attributes: env : Environment lib : LocalIdentifierBindings synthesized attributes: annotatedTree : SELF originalTree : SELF params : [(String, Type)] alternatives: alternative Cons: child hd : ParamDef child tl : ParamDefList visit 0: local annotatedTree : _ local originalTree : _ alternative Nil: visit 0: local annotatedTree : _ local originalTree : _ -} type ParamDefList = [(ParamDef)] -- cata sem_ParamDefList :: ParamDefList -> T_ParamDefList sem_ParamDefList list = (Prelude.foldr sem_ParamDefList_Cons sem_ParamDefList_Nil (Prelude.map sem_ParamDef list) ) -- semantic domain type T_ParamDefList = Environment -> LocalIdentifierBindings -> ( ParamDefList,ParamDefList,([(String, Type)])) data Inh_ParamDefList = Inh_ParamDefList {env_Inh_ParamDefList :: Environment,lib_Inh_ParamDefList :: LocalIdentifierBindings} data Syn_ParamDefList = Syn_ParamDefList {annotatedTree_Syn_ParamDefList :: ParamDefList,originalTree_Syn_ParamDefList :: ParamDefList,params_Syn_ParamDefList :: [(String, Type)]} wrap_ParamDefList :: T_ParamDefList -> Inh_ParamDefList -> Syn_ParamDefList wrap_ParamDefList sem (Inh_ParamDefList _lhsIenv _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree,_lhsOparams) = (sem _lhsIenv _lhsIlib ) in (Syn_ParamDefList _lhsOannotatedTree _lhsOoriginalTree _lhsOparams )) sem_ParamDefList_Cons :: T_ParamDef -> T_ParamDefList -> T_ParamDefList sem_ParamDefList_Cons hd_ tl_ = (\ _lhsIenv _lhsIlib -> (let _lhsOparams :: ([(String, Type)]) _lhsOannotatedTree :: ParamDefList _lhsOoriginalTree :: ParamDefList _hdOenv :: Environment _hdOlib :: LocalIdentifierBindings _tlOenv :: Environment _tlOlib :: LocalIdentifierBindings _hdIannotatedTree :: ParamDef _hdInamedType :: Type _hdIoriginalTree :: ParamDef _hdIparamName :: String _tlIannotatedTree :: ParamDefList _tlIoriginalTree :: ParamDefList _tlIparams :: ([(String, Type)]) -- "./TypeChecking/CreateFunction.ag"(line 64, column 13) _lhsOparams = {-# LINE 64 "./TypeChecking/CreateFunction.ag" #-} ((_hdIparamName, _hdInamedType) : _tlIparams) {-# LINE 6832 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} (:) _hdIannotatedTree _tlIannotatedTree {-# LINE 6837 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} (:) _hdIoriginalTree _tlIoriginalTree {-# LINE 6842 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 6847 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 6852 "AstInternal.hs" #-} -- copy rule (down) _hdOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 6857 "AstInternal.hs" #-} -- copy rule (down) _hdOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 6862 "AstInternal.hs" #-} -- copy rule (down) _tlOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 6867 "AstInternal.hs" #-} -- copy rule (down) _tlOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 6872 "AstInternal.hs" #-} ( _hdIannotatedTree,_hdInamedType,_hdIoriginalTree,_hdIparamName) = (hd_ _hdOenv _hdOlib ) ( _tlIannotatedTree,_tlIoriginalTree,_tlIparams) = (tl_ _tlOenv _tlOlib ) in ( _lhsOannotatedTree,_lhsOoriginalTree,_lhsOparams))) sem_ParamDefList_Nil :: T_ParamDefList sem_ParamDefList_Nil = (\ _lhsIenv _lhsIlib -> (let _lhsOparams :: ([(String, Type)]) _lhsOannotatedTree :: ParamDefList _lhsOoriginalTree :: ParamDefList -- "./TypeChecking/CreateFunction.ag"(line 63, column 12) _lhsOparams = {-# LINE 63 "./TypeChecking/CreateFunction.ag" #-} [] {-# LINE 6889 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 6894 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 6899 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 6904 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 6909 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree,_lhsOparams))) -- RaiseType --------------------------------------------------- {- visit 0: inherited attributes: env : Environment lib : LocalIdentifierBindings synthesized attributes: annotatedTree : SELF originalTree : SELF alternatives: alternative RError: visit 0: local annotatedTree : _ local originalTree : _ alternative RException: visit 0: local annotatedTree : _ local originalTree : _ alternative RNotice: visit 0: local annotatedTree : _ local originalTree : _ -} data RaiseType = RError | RException | RNotice deriving ( Data,Eq,Show,Typeable) -- cata sem_RaiseType :: RaiseType -> T_RaiseType sem_RaiseType (RError ) = (sem_RaiseType_RError ) sem_RaiseType (RException ) = (sem_RaiseType_RException ) sem_RaiseType (RNotice ) = (sem_RaiseType_RNotice ) -- semantic domain type T_RaiseType = Environment -> LocalIdentifierBindings -> ( RaiseType,RaiseType) data Inh_RaiseType = Inh_RaiseType {env_Inh_RaiseType :: Environment,lib_Inh_RaiseType :: LocalIdentifierBindings} data Syn_RaiseType = Syn_RaiseType {annotatedTree_Syn_RaiseType :: RaiseType,originalTree_Syn_RaiseType :: RaiseType} wrap_RaiseType :: T_RaiseType -> Inh_RaiseType -> Syn_RaiseType wrap_RaiseType sem (Inh_RaiseType _lhsIenv _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIenv _lhsIlib ) in (Syn_RaiseType _lhsOannotatedTree _lhsOoriginalTree )) sem_RaiseType_RError :: T_RaiseType sem_RaiseType_RError = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: RaiseType _lhsOoriginalTree :: RaiseType -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} RError {-# LINE 6970 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} RError {-# LINE 6975 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 6980 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 6985 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_RaiseType_RException :: T_RaiseType sem_RaiseType_RException = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: RaiseType _lhsOoriginalTree :: RaiseType -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} RException {-# LINE 6997 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} RException {-# LINE 7002 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 7007 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 7012 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_RaiseType_RNotice :: T_RaiseType sem_RaiseType_RNotice = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: RaiseType _lhsOoriginalTree :: RaiseType -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} RNotice {-# LINE 7024 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} RNotice {-# LINE 7029 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 7034 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 7039 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) -- RestartIdentity --------------------------------------------- {- visit 0: inherited attributes: env : Environment lib : LocalIdentifierBindings synthesized attributes: annotatedTree : SELF originalTree : SELF alternatives: alternative ContinueIdentity: visit 0: local annotatedTree : _ local originalTree : _ alternative RestartIdentity: visit 0: local annotatedTree : _ local originalTree : _ -} data RestartIdentity = ContinueIdentity | RestartIdentity deriving ( Data,Eq,Show,Typeable) -- cata sem_RestartIdentity :: RestartIdentity -> T_RestartIdentity sem_RestartIdentity (ContinueIdentity ) = (sem_RestartIdentity_ContinueIdentity ) sem_RestartIdentity (RestartIdentity ) = (sem_RestartIdentity_RestartIdentity ) -- semantic domain type T_RestartIdentity = Environment -> LocalIdentifierBindings -> ( RestartIdentity,RestartIdentity) data Inh_RestartIdentity = Inh_RestartIdentity {env_Inh_RestartIdentity :: Environment,lib_Inh_RestartIdentity :: LocalIdentifierBindings} data Syn_RestartIdentity = Syn_RestartIdentity {annotatedTree_Syn_RestartIdentity :: RestartIdentity,originalTree_Syn_RestartIdentity :: RestartIdentity} wrap_RestartIdentity :: T_RestartIdentity -> Inh_RestartIdentity -> Syn_RestartIdentity wrap_RestartIdentity sem (Inh_RestartIdentity _lhsIenv _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIenv _lhsIlib ) in (Syn_RestartIdentity _lhsOannotatedTree _lhsOoriginalTree )) sem_RestartIdentity_ContinueIdentity :: T_RestartIdentity sem_RestartIdentity_ContinueIdentity = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: RestartIdentity _lhsOoriginalTree :: RestartIdentity -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} ContinueIdentity {-# LINE 7093 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} ContinueIdentity {-# LINE 7098 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 7103 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 7108 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_RestartIdentity_RestartIdentity :: T_RestartIdentity sem_RestartIdentity_RestartIdentity = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: RestartIdentity _lhsOoriginalTree :: RestartIdentity -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} RestartIdentity {-# LINE 7120 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} RestartIdentity {-# LINE 7125 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 7130 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 7135 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) -- Root -------------------------------------------------------- {- visit 0: inherited attributes: env : Environment lib : LocalIdentifierBindings synthesized attributes: annotatedTree : SELF originalTree : SELF producedEnv : Environment producedLib : LocalIdentifierBindings alternatives: alternative Root: child statements : StatementList visit 0: local annotatedTree : _ local originalTree : _ -} data Root = Root (StatementList) deriving ( Show) -- cata sem_Root :: Root -> T_Root sem_Root (Root _statements ) = (sem_Root_Root (sem_StatementList _statements ) ) -- semantic domain type T_Root = Environment -> LocalIdentifierBindings -> ( Root,Root,Environment,LocalIdentifierBindings) data Inh_Root = Inh_Root {env_Inh_Root :: Environment,lib_Inh_Root :: LocalIdentifierBindings} data Syn_Root = Syn_Root {annotatedTree_Syn_Root :: Root,originalTree_Syn_Root :: Root,producedEnv_Syn_Root :: Environment,producedLib_Syn_Root :: LocalIdentifierBindings} wrap_Root :: T_Root -> Inh_Root -> Syn_Root wrap_Root sem (Inh_Root _lhsIenv _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree,_lhsOproducedEnv,_lhsOproducedLib) = (sem _lhsIenv _lhsIlib ) in (Syn_Root _lhsOannotatedTree _lhsOoriginalTree _lhsOproducedEnv _lhsOproducedLib )) sem_Root_Root :: T_StatementList -> T_Root sem_Root_Root statements_ = (\ _lhsIenv _lhsIlib -> (let _statementsOenvUpdates :: ([EnvironmentUpdate]) _statementsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _lhsOannotatedTree :: Root _lhsOoriginalTree :: Root _lhsOproducedEnv :: Environment _lhsOproducedLib :: LocalIdentifierBindings _statementsOenv :: Environment _statementsOlib :: LocalIdentifierBindings _statementsIannotatedTree :: StatementList _statementsIoriginalTree :: StatementList _statementsIproducedEnv :: Environment _statementsIproducedLib :: LocalIdentifierBindings -- "./TypeChecking/Statements.ag"(line 80, column 12) _statementsOenvUpdates = {-# LINE 80 "./TypeChecking/Statements.ag" #-} [] {-# LINE 7196 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 81, column 12) _statementsOlibUpdates = {-# LINE 81 "./TypeChecking/Statements.ag" #-} [] {-# LINE 7201 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Root _statementsIannotatedTree {-# LINE 7206 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Root _statementsIoriginalTree {-# LINE 7211 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 7216 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 7221 "AstInternal.hs" #-} -- copy rule (up) _lhsOproducedEnv = {-# LINE 27 "./TypeChecking/Statements.ag" #-} _statementsIproducedEnv {-# LINE 7226 "AstInternal.hs" #-} -- copy rule (up) _lhsOproducedLib = {-# LINE 28 "./TypeChecking/Statements.ag" #-} _statementsIproducedLib {-# LINE 7231 "AstInternal.hs" #-} -- copy rule (down) _statementsOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 7236 "AstInternal.hs" #-} -- copy rule (down) _statementsOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 7241 "AstInternal.hs" #-} ( _statementsIannotatedTree,_statementsIoriginalTree,_statementsIproducedEnv,_statementsIproducedLib) = (statements_ _statementsOenv _statementsOenvUpdates _statementsOlib _statementsOlibUpdates ) in ( _lhsOannotatedTree,_lhsOoriginalTree,_lhsOproducedEnv,_lhsOproducedLib))) -- RowConstraint ----------------------------------------------- {- visit 0: inherited attributes: env : Environment lib : LocalIdentifierBindings synthesized attributes: annotatedTree : SELF originalTree : SELF alternatives: alternative NotNullConstraint: child ann : {Annotation} child name : {String} visit 0: local annotatedTree : _ local originalTree : _ alternative NullConstraint: child ann : {Annotation} child name : {String} visit 0: local annotatedTree : _ local originalTree : _ alternative RowCheckConstraint: child ann : {Annotation} child name : {String} child expression : Expression visit 0: local annotatedTree : _ local originalTree : _ alternative RowPrimaryKeyConstraint: child ann : {Annotation} child name : {String} visit 0: local annotatedTree : _ local originalTree : _ alternative RowReferenceConstraint: child ann : {Annotation} child name : {String} child table : {String} child att : {Maybe String} child onUpdate : Cascade child onDelete : Cascade visit 0: local annotatedTree : _ local originalTree : _ alternative RowUniqueConstraint: child ann : {Annotation} child name : {String} visit 0: local annotatedTree : _ local originalTree : _ -} data RowConstraint = NotNullConstraint (Annotation) (String) | NullConstraint (Annotation) (String) | RowCheckConstraint (Annotation) (String) (Expression) | RowPrimaryKeyConstraint (Annotation) (String) | RowReferenceConstraint (Annotation) (String) (String) (Maybe String) (Cascade) (Cascade) | RowUniqueConstraint (Annotation) (String) deriving ( Data,Eq,Show,Typeable) -- cata sem_RowConstraint :: RowConstraint -> T_RowConstraint sem_RowConstraint (NotNullConstraint _ann _name ) = (sem_RowConstraint_NotNullConstraint _ann _name ) sem_RowConstraint (NullConstraint _ann _name ) = (sem_RowConstraint_NullConstraint _ann _name ) sem_RowConstraint (RowCheckConstraint _ann _name _expression ) = (sem_RowConstraint_RowCheckConstraint _ann _name (sem_Expression _expression ) ) sem_RowConstraint (RowPrimaryKeyConstraint _ann _name ) = (sem_RowConstraint_RowPrimaryKeyConstraint _ann _name ) sem_RowConstraint (RowReferenceConstraint _ann _name _table _att _onUpdate _onDelete ) = (sem_RowConstraint_RowReferenceConstraint _ann _name _table _att (sem_Cascade _onUpdate ) (sem_Cascade _onDelete ) ) sem_RowConstraint (RowUniqueConstraint _ann _name ) = (sem_RowConstraint_RowUniqueConstraint _ann _name ) -- semantic domain type T_RowConstraint = Environment -> LocalIdentifierBindings -> ( RowConstraint,RowConstraint) data Inh_RowConstraint = Inh_RowConstraint {env_Inh_RowConstraint :: Environment,lib_Inh_RowConstraint :: LocalIdentifierBindings} data Syn_RowConstraint = Syn_RowConstraint {annotatedTree_Syn_RowConstraint :: RowConstraint,originalTree_Syn_RowConstraint :: RowConstraint} wrap_RowConstraint :: T_RowConstraint -> Inh_RowConstraint -> Syn_RowConstraint wrap_RowConstraint sem (Inh_RowConstraint _lhsIenv _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIenv _lhsIlib ) in (Syn_RowConstraint _lhsOannotatedTree _lhsOoriginalTree )) sem_RowConstraint_NotNullConstraint :: Annotation -> String -> T_RowConstraint sem_RowConstraint_NotNullConstraint ann_ name_ = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: RowConstraint _lhsOoriginalTree :: RowConstraint -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} NotNullConstraint ann_ name_ {-# LINE 7344 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} NotNullConstraint ann_ name_ {-# LINE 7349 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 7354 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 7359 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_RowConstraint_NullConstraint :: Annotation -> String -> T_RowConstraint sem_RowConstraint_NullConstraint ann_ name_ = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: RowConstraint _lhsOoriginalTree :: RowConstraint -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} NullConstraint ann_ name_ {-# LINE 7373 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} NullConstraint ann_ name_ {-# LINE 7378 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 7383 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 7388 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_RowConstraint_RowCheckConstraint :: Annotation -> String -> T_Expression -> T_RowConstraint sem_RowConstraint_RowCheckConstraint ann_ name_ expression_ = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: RowConstraint _lhsOoriginalTree :: RowConstraint _expressionOenv :: Environment _expressionOlib :: LocalIdentifierBindings _expressionIannotatedTree :: Expression _expressionIliftedColumnName :: String _expressionIoriginalTree :: Expression -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} RowCheckConstraint ann_ name_ _expressionIannotatedTree {-# LINE 7408 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} RowCheckConstraint ann_ name_ _expressionIoriginalTree {-# LINE 7413 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 7418 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 7423 "AstInternal.hs" #-} -- copy rule (down) _expressionOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 7428 "AstInternal.hs" #-} -- copy rule (down) _expressionOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 7433 "AstInternal.hs" #-} ( _expressionIannotatedTree,_expressionIliftedColumnName,_expressionIoriginalTree) = (expression_ _expressionOenv _expressionOlib ) in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_RowConstraint_RowPrimaryKeyConstraint :: Annotation -> String -> T_RowConstraint sem_RowConstraint_RowPrimaryKeyConstraint ann_ name_ = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: RowConstraint _lhsOoriginalTree :: RowConstraint -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} RowPrimaryKeyConstraint ann_ name_ {-# LINE 7449 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} RowPrimaryKeyConstraint ann_ name_ {-# LINE 7454 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 7459 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 7464 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_RowConstraint_RowReferenceConstraint :: Annotation -> String -> String -> (Maybe String) -> T_Cascade -> T_Cascade -> T_RowConstraint sem_RowConstraint_RowReferenceConstraint ann_ name_ table_ att_ onUpdate_ onDelete_ = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: RowConstraint _lhsOoriginalTree :: RowConstraint _onUpdateOenv :: Environment _onUpdateOlib :: LocalIdentifierBindings _onDeleteOenv :: Environment _onDeleteOlib :: LocalIdentifierBindings _onUpdateIannotatedTree :: Cascade _onUpdateIoriginalTree :: Cascade _onDeleteIannotatedTree :: Cascade _onDeleteIoriginalTree :: Cascade -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} RowReferenceConstraint ann_ name_ table_ att_ _onUpdateIannotatedTree _onDeleteIannotatedTree {-# LINE 7490 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} RowReferenceConstraint ann_ name_ table_ att_ _onUpdateIoriginalTree _onDeleteIoriginalTree {-# LINE 7495 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 7500 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 7505 "AstInternal.hs" #-} -- copy rule (down) _onUpdateOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 7510 "AstInternal.hs" #-} -- copy rule (down) _onUpdateOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 7515 "AstInternal.hs" #-} -- copy rule (down) _onDeleteOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 7520 "AstInternal.hs" #-} -- copy rule (down) _onDeleteOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 7525 "AstInternal.hs" #-} ( _onUpdateIannotatedTree,_onUpdateIoriginalTree) = (onUpdate_ _onUpdateOenv _onUpdateOlib ) ( _onDeleteIannotatedTree,_onDeleteIoriginalTree) = (onDelete_ _onDeleteOenv _onDeleteOlib ) in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_RowConstraint_RowUniqueConstraint :: Annotation -> String -> T_RowConstraint sem_RowConstraint_RowUniqueConstraint ann_ name_ = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: RowConstraint _lhsOoriginalTree :: RowConstraint -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} RowUniqueConstraint ann_ name_ {-# LINE 7543 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} RowUniqueConstraint ann_ name_ {-# LINE 7548 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 7553 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 7558 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) -- RowConstraintList ------------------------------------------- {- visit 0: inherited attributes: env : Environment lib : LocalIdentifierBindings synthesized attributes: annotatedTree : SELF originalTree : SELF alternatives: alternative Cons: child hd : RowConstraint child tl : RowConstraintList visit 0: local annotatedTree : _ local originalTree : _ alternative Nil: visit 0: local annotatedTree : _ local originalTree : _ -} type RowConstraintList = [(RowConstraint)] -- cata sem_RowConstraintList :: RowConstraintList -> T_RowConstraintList sem_RowConstraintList list = (Prelude.foldr sem_RowConstraintList_Cons sem_RowConstraintList_Nil (Prelude.map sem_RowConstraint list) ) -- semantic domain type T_RowConstraintList = Environment -> LocalIdentifierBindings -> ( RowConstraintList,RowConstraintList) data Inh_RowConstraintList = Inh_RowConstraintList {env_Inh_RowConstraintList :: Environment,lib_Inh_RowConstraintList :: LocalIdentifierBindings} data Syn_RowConstraintList = Syn_RowConstraintList {annotatedTree_Syn_RowConstraintList :: RowConstraintList,originalTree_Syn_RowConstraintList :: RowConstraintList} wrap_RowConstraintList :: T_RowConstraintList -> Inh_RowConstraintList -> Syn_RowConstraintList wrap_RowConstraintList sem (Inh_RowConstraintList _lhsIenv _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIenv _lhsIlib ) in (Syn_RowConstraintList _lhsOannotatedTree _lhsOoriginalTree )) sem_RowConstraintList_Cons :: T_RowConstraint -> T_RowConstraintList -> T_RowConstraintList sem_RowConstraintList_Cons hd_ tl_ = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: RowConstraintList _lhsOoriginalTree :: RowConstraintList _hdOenv :: Environment _hdOlib :: LocalIdentifierBindings _tlOenv :: Environment _tlOlib :: LocalIdentifierBindings _hdIannotatedTree :: RowConstraint _hdIoriginalTree :: RowConstraint _tlIannotatedTree :: RowConstraintList _tlIoriginalTree :: RowConstraintList -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} (:) _hdIannotatedTree _tlIannotatedTree {-# LINE 7620 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} (:) _hdIoriginalTree _tlIoriginalTree {-# LINE 7625 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 7630 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 7635 "AstInternal.hs" #-} -- copy rule (down) _hdOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 7640 "AstInternal.hs" #-} -- copy rule (down) _hdOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 7645 "AstInternal.hs" #-} -- copy rule (down) _tlOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 7650 "AstInternal.hs" #-} -- copy rule (down) _tlOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 7655 "AstInternal.hs" #-} ( _hdIannotatedTree,_hdIoriginalTree) = (hd_ _hdOenv _hdOlib ) ( _tlIannotatedTree,_tlIoriginalTree) = (tl_ _tlOenv _tlOlib ) in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_RowConstraintList_Nil :: T_RowConstraintList sem_RowConstraintList_Nil = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: RowConstraintList _lhsOoriginalTree :: RowConstraintList -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 7671 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 7676 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 7681 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 7686 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) -- SelectExpression -------------------------------------------- {- visit 0: inherited attributes: env : Environment lib : LocalIdentifierBindings synthesized attributes: annotatedTree : SELF libUpdates : [LocalIdentifierBindingsUpdate] originalTree : SELF alternatives: alternative CombineSelect: child ann : {Annotation} child ctype : CombineType child sel1 : SelectExpression child sel2 : SelectExpression visit 0: local tpe : _ local backTree : _ local annotatedTree : _ local originalTree : _ alternative Select: child ann : {Annotation} child selDistinct : Distinct child selSelectList : SelectList child selTref : TableRefList child selWhere : MaybeBoolExpression child selGroupBy : ExpressionList child selHaving : MaybeBoolExpression child selOrderBy : ExpressionDirectionPairList child selLimit : MaybeExpression child selOffset : MaybeExpression visit 0: local newLib : _ local tpe : _ local backTree : _ local annotatedTree : _ local originalTree : _ alternative Values: child ann : {Annotation} child vll : ExpressionListList visit 0: local tpe : _ local backTree : _ local annotatedTree : _ local originalTree : _ -} data SelectExpression = CombineSelect (Annotation) (CombineType) (SelectExpression) (SelectExpression) | Select (Annotation) (Distinct) (SelectList) (TableRefList) (MaybeBoolExpression) (ExpressionList) (MaybeBoolExpression) (ExpressionDirectionPairList) (MaybeExpression) (MaybeExpression) | Values (Annotation) (ExpressionListList) deriving ( Data,Eq,Show,Typeable) -- cata sem_SelectExpression :: SelectExpression -> T_SelectExpression sem_SelectExpression (CombineSelect _ann _ctype _sel1 _sel2 ) = (sem_SelectExpression_CombineSelect _ann (sem_CombineType _ctype ) (sem_SelectExpression _sel1 ) (sem_SelectExpression _sel2 ) ) sem_SelectExpression (Select _ann _selDistinct _selSelectList _selTref _selWhere _selGroupBy _selHaving _selOrderBy _selLimit _selOffset ) = (sem_SelectExpression_Select _ann (sem_Distinct _selDistinct ) (sem_SelectList _selSelectList ) (sem_TableRefList _selTref ) (sem_MaybeBoolExpression _selWhere ) (sem_ExpressionList _selGroupBy ) (sem_MaybeBoolExpression _selHaving ) (sem_ExpressionDirectionPairList _selOrderBy ) (sem_MaybeExpression _selLimit ) (sem_MaybeExpression _selOffset ) ) sem_SelectExpression (Values _ann _vll ) = (sem_SelectExpression_Values _ann (sem_ExpressionListList _vll ) ) -- semantic domain type T_SelectExpression = Environment -> LocalIdentifierBindings -> ( SelectExpression,([LocalIdentifierBindingsUpdate]),SelectExpression) data Inh_SelectExpression = Inh_SelectExpression {env_Inh_SelectExpression :: Environment,lib_Inh_SelectExpression :: LocalIdentifierBindings} data Syn_SelectExpression = Syn_SelectExpression {annotatedTree_Syn_SelectExpression :: SelectExpression,libUpdates_Syn_SelectExpression :: [LocalIdentifierBindingsUpdate],originalTree_Syn_SelectExpression :: SelectExpression} wrap_SelectExpression :: T_SelectExpression -> Inh_SelectExpression -> Syn_SelectExpression wrap_SelectExpression sem (Inh_SelectExpression _lhsIenv _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOlibUpdates,_lhsOoriginalTree) = (sem _lhsIenv _lhsIlib ) in (Syn_SelectExpression _lhsOannotatedTree _lhsOlibUpdates _lhsOoriginalTree )) sem_SelectExpression_CombineSelect :: Annotation -> T_CombineType -> T_SelectExpression -> T_SelectExpression -> T_SelectExpression sem_SelectExpression_CombineSelect ann_ ctype_ sel1_ sel2_ = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: SelectExpression _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _lhsOoriginalTree :: SelectExpression _ctypeOenv :: Environment _ctypeOlib :: LocalIdentifierBindings _sel1Oenv :: Environment _sel1Olib :: LocalIdentifierBindings _sel2Oenv :: Environment _sel2Olib :: LocalIdentifierBindings _ctypeIannotatedTree :: CombineType _ctypeIoriginalTree :: CombineType _sel1IannotatedTree :: SelectExpression _sel1IlibUpdates :: ([LocalIdentifierBindingsUpdate]) _sel1IoriginalTree :: SelectExpression _sel2IannotatedTree :: SelectExpression _sel2IlibUpdates :: ([LocalIdentifierBindingsUpdate]) _sel2IoriginalTree :: SelectExpression -- "./TypeChecking/SelectStatement.ag"(line 26, column 9) _lhsOannotatedTree = {-# LINE 26 "./TypeChecking/SelectStatement.ag" #-} annTypesAndErrors _backTree (tpeToT _tpe ) (getErrors _tpe ) Nothing {-# LINE 7793 "AstInternal.hs" #-} -- "./TypeChecking/SelectStatement.ag"(line 132, column 9) _tpe = {-# LINE 132 "./TypeChecking/SelectStatement.ag" #-} let sel1t = getTypeAnnotation _sel1IannotatedTree sel2t = getTypeAnnotation _sel2IannotatedTree in dependsOnRTpe [sel1t, sel2t] $ typeCheckCombineSelect _lhsIenv sel1t sel2t {-# LINE 7801 "AstInternal.hs" #-} -- "./TypeChecking/SelectStatement.ag"(line 137, column 9) _backTree = {-# LINE 137 "./TypeChecking/SelectStatement.ag" #-} CombineSelect ann_ _ctypeIannotatedTree _sel1IannotatedTree _sel2IannotatedTree {-# LINE 7808 "AstInternal.hs" #-} -- "./TypeChecking/SelectLists.ag"(line 87, column 11) _lhsOlibUpdates = {-# LINE 87 "./TypeChecking/SelectLists.ag" #-} [] {-# LINE 7813 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} CombineSelect ann_ _ctypeIannotatedTree _sel1IannotatedTree _sel2IannotatedTree {-# LINE 7818 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} CombineSelect ann_ _ctypeIoriginalTree _sel1IoriginalTree _sel2IoriginalTree {-# LINE 7823 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 7828 "AstInternal.hs" #-} -- copy rule (down) _ctypeOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 7833 "AstInternal.hs" #-} -- copy rule (down) _ctypeOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 7838 "AstInternal.hs" #-} -- copy rule (down) _sel1Oenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 7843 "AstInternal.hs" #-} -- copy rule (down) _sel1Olib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 7848 "AstInternal.hs" #-} -- copy rule (down) _sel2Oenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 7853 "AstInternal.hs" #-} -- copy rule (down) _sel2Olib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 7858 "AstInternal.hs" #-} ( _ctypeIannotatedTree,_ctypeIoriginalTree) = (ctype_ _ctypeOenv _ctypeOlib ) ( _sel1IannotatedTree,_sel1IlibUpdates,_sel1IoriginalTree) = (sel1_ _sel1Oenv _sel1Olib ) ( _sel2IannotatedTree,_sel2IlibUpdates,_sel2IoriginalTree) = (sel2_ _sel2Oenv _sel2Olib ) in ( _lhsOannotatedTree,_lhsOlibUpdates,_lhsOoriginalTree))) sem_SelectExpression_Select :: Annotation -> T_Distinct -> T_SelectList -> T_TableRefList -> T_MaybeBoolExpression -> T_ExpressionList -> T_MaybeBoolExpression -> T_ExpressionDirectionPairList -> T_MaybeExpression -> T_MaybeExpression -> T_SelectExpression sem_SelectExpression_Select ann_ selDistinct_ selSelectList_ selTref_ selWhere_ selGroupBy_ selHaving_ selOrderBy_ selLimit_ selOffset_ = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: SelectExpression _selSelectListOlib :: LocalIdentifierBindings _selWhereOlib :: LocalIdentifierBindings _selGroupByOlib :: LocalIdentifierBindings _selOrderByOlib :: LocalIdentifierBindings _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _lhsOoriginalTree :: SelectExpression _selDistinctOenv :: Environment _selDistinctOlib :: LocalIdentifierBindings _selSelectListOenv :: Environment _selTrefOenv :: Environment _selTrefOlib :: LocalIdentifierBindings _selWhereOenv :: Environment _selGroupByOenv :: Environment _selHavingOenv :: Environment _selHavingOlib :: LocalIdentifierBindings _selOrderByOenv :: Environment _selLimitOenv :: Environment _selLimitOlib :: LocalIdentifierBindings _selOffsetOenv :: Environment _selOffsetOlib :: LocalIdentifierBindings _selDistinctIannotatedTree :: Distinct _selDistinctIoriginalTree :: Distinct _selSelectListIannotatedTree :: SelectList _selSelectListIlibUpdates :: ([LocalIdentifierBindingsUpdate]) _selSelectListIlistType :: ([(String,Type)]) _selSelectListIoriginalTree :: SelectList _selTrefIannotatedTree :: TableRefList _selTrefIlibUpdates :: ([LocalIdentifierBindingsUpdate]) _selTrefIoriginalTree :: TableRefList _selWhereIannotatedTree :: MaybeBoolExpression _selWhereIoriginalTree :: MaybeBoolExpression _selGroupByIannotatedTree :: ExpressionList _selGroupByIoriginalTree :: ExpressionList _selGroupByItypeList :: ([Type]) _selHavingIannotatedTree :: MaybeBoolExpression _selHavingIoriginalTree :: MaybeBoolExpression _selOrderByIannotatedTree :: ExpressionDirectionPairList _selOrderByIoriginalTree :: ExpressionDirectionPairList _selLimitIannotatedTree :: MaybeExpression _selLimitIoriginalTree :: MaybeExpression _selOffsetIannotatedTree :: MaybeExpression _selOffsetIoriginalTree :: MaybeExpression -- "./TypeChecking/SelectStatement.ag"(line 26, column 9) _lhsOannotatedTree = {-# LINE 26 "./TypeChecking/SelectStatement.ag" #-} annTypesAndErrors _backTree (tpeToT _tpe ) (getErrors _tpe ) Nothing {-# LINE 7930 "AstInternal.hs" #-} -- "./TypeChecking/SelectStatement.ag"(line 97, column 10) _newLib = {-# LINE 97 "./TypeChecking/SelectStatement.ag" #-} case updateBindings _lhsIlib _lhsIenv _selTrefIlibUpdates of Left x -> error $ show x Right e -> e {-# LINE 7937 "AstInternal.hs" #-} -- "./TypeChecking/SelectStatement.ag"(line 100, column 10) _selSelectListOlib = {-# LINE 100 "./TypeChecking/SelectStatement.ag" #-} _newLib {-# LINE 7942 "AstInternal.hs" #-} -- "./TypeChecking/SelectStatement.ag"(line 101, column 10) _selWhereOlib = {-# LINE 101 "./TypeChecking/SelectStatement.ag" #-} _newLib {-# LINE 7947 "AstInternal.hs" #-} -- "./TypeChecking/SelectStatement.ag"(line 102, column 10) _selGroupByOlib = {-# LINE 102 "./TypeChecking/SelectStatement.ag" #-} _newLib {-# LINE 7952 "AstInternal.hs" #-} -- "./TypeChecking/SelectStatement.ag"(line 103, column 10) _selOrderByOlib = {-# LINE 103 "./TypeChecking/SelectStatement.ag" #-} _newLib {-# LINE 7957 "AstInternal.hs" #-} -- "./TypeChecking/SelectStatement.ag"(line 114, column 9) _tpe = {-# LINE 114 "./TypeChecking/SelectStatement.ag" #-} do Right $ case _selSelectListIlistType of [(_,Pseudo Void)] -> Pseudo Void _ -> SetOfType $ CompositeType _selSelectListIlistType {-# LINE 7965 "AstInternal.hs" #-} -- "./TypeChecking/SelectStatement.ag"(line 121, column 9) _backTree = {-# LINE 121 "./TypeChecking/SelectStatement.ag" #-} Select ann_ _selDistinctIannotatedTree _selSelectListIannotatedTree _selTrefIannotatedTree _selWhereIannotatedTree _selGroupByIannotatedTree _selHavingIannotatedTree _selOrderByIannotatedTree _selLimitIannotatedTree _selOffsetIannotatedTree {-# LINE 7979 "AstInternal.hs" #-} -- "./TypeChecking/SelectLists.ag"(line 85, column 9) _lhsOlibUpdates = {-# LINE 85 "./TypeChecking/SelectLists.ag" #-} _selSelectListIlibUpdates {-# LINE 7984 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Select ann_ _selDistinctIannotatedTree _selSelectListIannotatedTree _selTrefIannotatedTree _selWhereIannotatedTree _selGroupByIannotatedTree _selHavingIannotatedTree _selOrderByIannotatedTree _selLimitIannotatedTree _selOffsetIannotatedTree {-# LINE 7989 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Select ann_ _selDistinctIoriginalTree _selSelectListIoriginalTree _selTrefIoriginalTree _selWhereIoriginalTree _selGroupByIoriginalTree _selHavingIoriginalTree _selOrderByIoriginalTree _selLimitIoriginalTree _selOffsetIoriginalTree {-# LINE 7994 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 7999 "AstInternal.hs" #-} -- copy rule (down) _selDistinctOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 8004 "AstInternal.hs" #-} -- copy rule (down) _selDistinctOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 8009 "AstInternal.hs" #-} -- copy rule (down) _selSelectListOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 8014 "AstInternal.hs" #-} -- copy rule (down) _selTrefOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 8019 "AstInternal.hs" #-} -- copy rule (down) _selTrefOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 8024 "AstInternal.hs" #-} -- copy rule (down) _selWhereOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 8029 "AstInternal.hs" #-} -- copy rule (down) _selGroupByOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 8034 "AstInternal.hs" #-} -- copy rule (down) _selHavingOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 8039 "AstInternal.hs" #-} -- copy rule (down) _selHavingOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 8044 "AstInternal.hs" #-} -- copy rule (down) _selOrderByOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 8049 "AstInternal.hs" #-} -- copy rule (down) _selLimitOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 8054 "AstInternal.hs" #-} -- copy rule (down) _selLimitOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 8059 "AstInternal.hs" #-} -- copy rule (down) _selOffsetOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 8064 "AstInternal.hs" #-} -- copy rule (down) _selOffsetOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 8069 "AstInternal.hs" #-} ( _selDistinctIannotatedTree,_selDistinctIoriginalTree) = (selDistinct_ _selDistinctOenv _selDistinctOlib ) ( _selSelectListIannotatedTree,_selSelectListIlibUpdates,_selSelectListIlistType,_selSelectListIoriginalTree) = (selSelectList_ _selSelectListOenv _selSelectListOlib ) ( _selTrefIannotatedTree,_selTrefIlibUpdates,_selTrefIoriginalTree) = (selTref_ _selTrefOenv _selTrefOlib ) ( _selWhereIannotatedTree,_selWhereIoriginalTree) = (selWhere_ _selWhereOenv _selWhereOlib ) ( _selGroupByIannotatedTree,_selGroupByIoriginalTree,_selGroupByItypeList) = (selGroupBy_ _selGroupByOenv _selGroupByOlib ) ( _selHavingIannotatedTree,_selHavingIoriginalTree) = (selHaving_ _selHavingOenv _selHavingOlib ) ( _selOrderByIannotatedTree,_selOrderByIoriginalTree) = (selOrderBy_ _selOrderByOenv _selOrderByOlib ) ( _selLimitIannotatedTree,_selLimitIoriginalTree) = (selLimit_ _selLimitOenv _selLimitOlib ) ( _selOffsetIannotatedTree,_selOffsetIoriginalTree) = (selOffset_ _selOffsetOenv _selOffsetOlib ) in ( _lhsOannotatedTree,_lhsOlibUpdates,_lhsOoriginalTree))) sem_SelectExpression_Values :: Annotation -> T_ExpressionListList -> T_SelectExpression sem_SelectExpression_Values ann_ vll_ = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: SelectExpression _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _lhsOoriginalTree :: SelectExpression _vllOenv :: Environment _vllOlib :: LocalIdentifierBindings _vllIannotatedTree :: ExpressionListList _vllIoriginalTree :: ExpressionListList _vllItypeListList :: ([[Type]]) -- "./TypeChecking/SelectStatement.ag"(line 26, column 9) _lhsOannotatedTree = {-# LINE 26 "./TypeChecking/SelectStatement.ag" #-} annTypesAndErrors _backTree (tpeToT _tpe ) (getErrors _tpe ) Nothing {-# LINE 8110 "AstInternal.hs" #-} -- "./TypeChecking/SelectStatement.ag"(line 109, column 9) _tpe = {-# LINE 109 "./TypeChecking/SelectStatement.ag" #-} typeCheckValuesExpr _lhsIenv _vllItypeListList {-# LINE 8117 "AstInternal.hs" #-} -- "./TypeChecking/SelectStatement.ag"(line 112, column 9) _backTree = {-# LINE 112 "./TypeChecking/SelectStatement.ag" #-} Values ann_ _vllIannotatedTree {-# LINE 8122 "AstInternal.hs" #-} -- "./TypeChecking/SelectLists.ag"(line 87, column 11) _lhsOlibUpdates = {-# LINE 87 "./TypeChecking/SelectLists.ag" #-} [] {-# LINE 8127 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Values ann_ _vllIannotatedTree {-# LINE 8132 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Values ann_ _vllIoriginalTree {-# LINE 8137 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 8142 "AstInternal.hs" #-} -- copy rule (down) _vllOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 8147 "AstInternal.hs" #-} -- copy rule (down) _vllOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 8152 "AstInternal.hs" #-} ( _vllIannotatedTree,_vllIoriginalTree,_vllItypeListList) = (vll_ _vllOenv _vllOlib ) in ( _lhsOannotatedTree,_lhsOlibUpdates,_lhsOoriginalTree))) -- SelectItem -------------------------------------------------- {- visit 0: inherited attributes: env : Environment lib : LocalIdentifierBindings synthesized attributes: annotatedTree : SELF columnName : String itemType : Type originalTree : SELF alternatives: alternative SelExp: child ann : {Annotation} child ex : Expression visit 0: local annotatedTree : _ local originalTree : _ alternative SelectItem: child ann : {Annotation} child ex : Expression child name : {String} visit 0: local annotatedTree : _ local originalTree : _ -} data SelectItem = SelExp (Annotation) (Expression) | SelectItem (Annotation) (Expression) (String) deriving ( Data,Eq,Show,Typeable) -- cata sem_SelectItem :: SelectItem -> T_SelectItem sem_SelectItem (SelExp _ann _ex ) = (sem_SelectItem_SelExp _ann (sem_Expression _ex ) ) sem_SelectItem (SelectItem _ann _ex _name ) = (sem_SelectItem_SelectItem _ann (sem_Expression _ex ) _name ) -- semantic domain type T_SelectItem = Environment -> LocalIdentifierBindings -> ( SelectItem,String,Type,SelectItem) data Inh_SelectItem = Inh_SelectItem {env_Inh_SelectItem :: Environment,lib_Inh_SelectItem :: LocalIdentifierBindings} data Syn_SelectItem = Syn_SelectItem {annotatedTree_Syn_SelectItem :: SelectItem,columnName_Syn_SelectItem :: String,itemType_Syn_SelectItem :: Type,originalTree_Syn_SelectItem :: SelectItem} wrap_SelectItem :: T_SelectItem -> Inh_SelectItem -> Syn_SelectItem wrap_SelectItem sem (Inh_SelectItem _lhsIenv _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOcolumnName,_lhsOitemType,_lhsOoriginalTree) = (sem _lhsIenv _lhsIlib ) in (Syn_SelectItem _lhsOannotatedTree _lhsOcolumnName _lhsOitemType _lhsOoriginalTree )) sem_SelectItem_SelExp :: Annotation -> T_Expression -> T_SelectItem sem_SelectItem_SelExp ann_ ex_ = (\ _lhsIenv _lhsIlib -> (let _lhsOitemType :: Type _lhsOcolumnName :: String _lhsOannotatedTree :: SelectItem _lhsOoriginalTree :: SelectItem _exOenv :: Environment _exOlib :: LocalIdentifierBindings _exIannotatedTree :: Expression _exIliftedColumnName :: String _exIoriginalTree :: Expression -- "./TypeChecking/SelectLists.ag"(line 13, column 9) _annotatedTree = {-# LINE 13 "./TypeChecking/SelectLists.ag" #-} SelExp ann_ $ fixStar _exIannotatedTree {-# LINE 8224 "AstInternal.hs" #-} -- "./TypeChecking/SelectLists.ag"(line 35, column 9) _lhsOitemType = {-# LINE 35 "./TypeChecking/SelectLists.ag" #-} getTypeAnnotation _exIannotatedTree {-# LINE 8229 "AstInternal.hs" #-} -- "./TypeChecking/SelectLists.ag"(line 181, column 14) _lhsOcolumnName = {-# LINE 181 "./TypeChecking/SelectLists.ag" #-} case _exIliftedColumnName of "" -> "?column?" s -> s {-# LINE 8236 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} SelExp ann_ _exIoriginalTree {-# LINE 8241 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 8246 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 8251 "AstInternal.hs" #-} -- copy rule (down) _exOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 8256 "AstInternal.hs" #-} -- copy rule (down) _exOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 8261 "AstInternal.hs" #-} ( _exIannotatedTree,_exIliftedColumnName,_exIoriginalTree) = (ex_ _exOenv _exOlib ) in ( _lhsOannotatedTree,_lhsOcolumnName,_lhsOitemType,_lhsOoriginalTree))) sem_SelectItem_SelectItem :: Annotation -> T_Expression -> String -> T_SelectItem sem_SelectItem_SelectItem ann_ ex_ name_ = (\ _lhsIenv _lhsIlib -> (let _lhsOitemType :: Type _lhsOcolumnName :: String _lhsOannotatedTree :: SelectItem _lhsOoriginalTree :: SelectItem _exOenv :: Environment _exOlib :: LocalIdentifierBindings _exIannotatedTree :: Expression _exIliftedColumnName :: String _exIoriginalTree :: Expression -- "./TypeChecking/SelectLists.ag"(line 15, column 9) _annotatedTree = {-# LINE 15 "./TypeChecking/SelectLists.ag" #-} SelectItem ann_ (fixStar _exIannotatedTree) name_ {-# LINE 8285 "AstInternal.hs" #-} -- "./TypeChecking/SelectLists.ag"(line 35, column 9) _lhsOitemType = {-# LINE 35 "./TypeChecking/SelectLists.ag" #-} getTypeAnnotation _exIannotatedTree {-# LINE 8290 "AstInternal.hs" #-} -- "./TypeChecking/SelectLists.ag"(line 184, column 18) _lhsOcolumnName = {-# LINE 184 "./TypeChecking/SelectLists.ag" #-} name_ {-# LINE 8295 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} SelectItem ann_ _exIoriginalTree name_ {-# LINE 8300 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 8305 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 8310 "AstInternal.hs" #-} -- copy rule (down) _exOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 8315 "AstInternal.hs" #-} -- copy rule (down) _exOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 8320 "AstInternal.hs" #-} ( _exIannotatedTree,_exIliftedColumnName,_exIoriginalTree) = (ex_ _exOenv _exOlib ) in ( _lhsOannotatedTree,_lhsOcolumnName,_lhsOitemType,_lhsOoriginalTree))) -- SelectItemList ---------------------------------------------- {- visit 0: inherited attributes: env : Environment lib : LocalIdentifierBindings synthesized attributes: annotatedTree : SELF listType : [(String,Type)] originalTree : SELF alternatives: alternative Cons: child hd : SelectItem child tl : SelectItemList visit 0: local annotatedTree : _ local originalTree : _ alternative Nil: visit 0: local annotatedTree : _ local originalTree : _ -} type SelectItemList = [(SelectItem)] -- cata sem_SelectItemList :: SelectItemList -> T_SelectItemList sem_SelectItemList list = (Prelude.foldr sem_SelectItemList_Cons sem_SelectItemList_Nil (Prelude.map sem_SelectItem list) ) -- semantic domain type T_SelectItemList = Environment -> LocalIdentifierBindings -> ( SelectItemList,([(String,Type)]),SelectItemList) data Inh_SelectItemList = Inh_SelectItemList {env_Inh_SelectItemList :: Environment,lib_Inh_SelectItemList :: LocalIdentifierBindings} data Syn_SelectItemList = Syn_SelectItemList {annotatedTree_Syn_SelectItemList :: SelectItemList,listType_Syn_SelectItemList :: [(String,Type)],originalTree_Syn_SelectItemList :: SelectItemList} wrap_SelectItemList :: T_SelectItemList -> Inh_SelectItemList -> Syn_SelectItemList wrap_SelectItemList sem (Inh_SelectItemList _lhsIenv _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOlistType,_lhsOoriginalTree) = (sem _lhsIenv _lhsIlib ) in (Syn_SelectItemList _lhsOannotatedTree _lhsOlistType _lhsOoriginalTree )) sem_SelectItemList_Cons :: T_SelectItem -> T_SelectItemList -> T_SelectItemList sem_SelectItemList_Cons hd_ tl_ = (\ _lhsIenv _lhsIlib -> (let _lhsOlistType :: ([(String,Type)]) _lhsOannotatedTree :: SelectItemList _lhsOoriginalTree :: SelectItemList _hdOenv :: Environment _hdOlib :: LocalIdentifierBindings _tlOenv :: Environment _tlOlib :: LocalIdentifierBindings _hdIannotatedTree :: SelectItem _hdIcolumnName :: String _hdIitemType :: Type _hdIoriginalTree :: SelectItem _tlIannotatedTree :: SelectItemList _tlIlistType :: ([(String,Type)]) _tlIoriginalTree :: SelectItemList -- "./TypeChecking/SelectLists.ag"(line 29, column 12) _lhsOlistType = {-# LINE 29 "./TypeChecking/SelectLists.ag" #-} expandStar _lhsIlib _hdIcolumnName _hdIitemType _tlIlistType {-# LINE 8389 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} (:) _hdIannotatedTree _tlIannotatedTree {-# LINE 8394 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} (:) _hdIoriginalTree _tlIoriginalTree {-# LINE 8399 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 8404 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 8409 "AstInternal.hs" #-} -- copy rule (down) _hdOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 8414 "AstInternal.hs" #-} -- copy rule (down) _hdOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 8419 "AstInternal.hs" #-} -- copy rule (down) _tlOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 8424 "AstInternal.hs" #-} -- copy rule (down) _tlOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 8429 "AstInternal.hs" #-} ( _hdIannotatedTree,_hdIcolumnName,_hdIitemType,_hdIoriginalTree) = (hd_ _hdOenv _hdOlib ) ( _tlIannotatedTree,_tlIlistType,_tlIoriginalTree) = (tl_ _tlOenv _tlOlib ) in ( _lhsOannotatedTree,_lhsOlistType,_lhsOoriginalTree))) sem_SelectItemList_Nil :: T_SelectItemList sem_SelectItemList_Nil = (\ _lhsIenv _lhsIlib -> (let _lhsOlistType :: ([(String,Type)]) _lhsOannotatedTree :: SelectItemList _lhsOoriginalTree :: SelectItemList -- "./TypeChecking/SelectLists.ag"(line 30, column 11) _lhsOlistType = {-# LINE 30 "./TypeChecking/SelectLists.ag" #-} [] {-# LINE 8446 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 8451 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 8456 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 8461 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 8466 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOlistType,_lhsOoriginalTree))) -- SelectList -------------------------------------------------- {- visit 0: inherited attributes: env : Environment lib : LocalIdentifierBindings synthesized attributes: annotatedTree : SELF libUpdates : [LocalIdentifierBindingsUpdate] listType : [(String,Type)] originalTree : SELF alternatives: alternative SelectList: child ann : {Annotation} child items : SelectItemList child into : StringList visit 0: local errs : _ local stuff : _ local annotatedTree : _ local originalTree : _ -} data SelectList = SelectList (Annotation) (SelectItemList) (StringList) deriving ( Data,Eq,Show,Typeable) -- cata sem_SelectList :: SelectList -> T_SelectList sem_SelectList (SelectList _ann _items _into ) = (sem_SelectList_SelectList _ann (sem_SelectItemList _items ) (sem_StringList _into ) ) -- semantic domain type T_SelectList = Environment -> LocalIdentifierBindings -> ( SelectList,([LocalIdentifierBindingsUpdate]),([(String,Type)]),SelectList) data Inh_SelectList = Inh_SelectList {env_Inh_SelectList :: Environment,lib_Inh_SelectList :: LocalIdentifierBindings} data Syn_SelectList = Syn_SelectList {annotatedTree_Syn_SelectList :: SelectList,libUpdates_Syn_SelectList :: [LocalIdentifierBindingsUpdate],listType_Syn_SelectList :: [(String,Type)],originalTree_Syn_SelectList :: SelectList} wrap_SelectList :: T_SelectList -> Inh_SelectList -> Syn_SelectList wrap_SelectList sem (Inh_SelectList _lhsIenv _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOlibUpdates,_lhsOlistType,_lhsOoriginalTree) = (sem _lhsIenv _lhsIlib ) in (Syn_SelectList _lhsOannotatedTree _lhsOlibUpdates _lhsOlistType _lhsOoriginalTree )) sem_SelectList_SelectList :: Annotation -> T_SelectItemList -> T_StringList -> T_SelectList sem_SelectList_SelectList ann_ items_ into_ = (\ _lhsIenv _lhsIlib -> (let _lhsOlistType :: ([(String,Type)]) _lhsOannotatedTree :: SelectList _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _lhsOoriginalTree :: SelectList _itemsOenv :: Environment _itemsOlib :: LocalIdentifierBindings _intoOenv :: Environment _intoOlib :: LocalIdentifierBindings _itemsIannotatedTree :: SelectItemList _itemsIlistType :: ([(String,Type)]) _itemsIoriginalTree :: SelectItemList _intoIannotatedTree :: StringList _intoIoriginalTree :: StringList _intoIstrings :: ([String]) -- "./TypeChecking/SelectLists.ag"(line 41, column 9) _lhsOlistType = {-# LINE 41 "./TypeChecking/SelectLists.ag" #-} _itemsIlistType {-# LINE 8535 "AstInternal.hs" #-} -- "./TypeChecking/SelectLists.ag"(line 43, column 9) _errs = {-# LINE 43 "./TypeChecking/SelectLists.ag" #-} case _stuff of (er,_) -> er {-# LINE 8541 "AstInternal.hs" #-} -- "./TypeChecking/SelectLists.ag"(line 45, column 9) _stuff = {-# LINE 45 "./TypeChecking/SelectLists.ag" #-} case () of _ | null sl -> ([],Nothing) | not (null targetTypeErrs) -> (targetTypeErrs,Nothing) | (case targetTypes of [PgRecord _] -> True _ -> False) -> ([],Just (head sl, CompositeType _itemsIlistType)) | matchingComposite /= Left [] -> (fromLeft [] matchingComposite,Nothing) | length sl /= length _itemsIlistType -> ([WrongNumberOfColumns],Nothing) | not (null assignErrs) -> (assignErrs,Nothing) | otherwise -> ([],Nothing) where targetTypeEithers = map (libLookupID _lhsIlib) sl targetTypeErrs = concat $ lefts $ targetTypeEithers targetTypes = rights $ targetTypeEithers typePairs = zip (map snd _itemsIlistType) targetTypes assignErrs = concat $ lefts $ map (uncurry $ checkAssignmentValid _lhsIenv) typePairs sl = _intoIstrings matchingComposite = case targetTypes of [t] | isCompositeType t -> checkAssignmentValid _lhsIenv (AnonymousRecordType (map snd _itemsIlistType)) t _ -> Left [] {-# LINE 8566 "AstInternal.hs" #-} -- "./TypeChecking/SelectLists.ag"(line 68, column 9) _lhsOannotatedTree = {-# LINE 68 "./TypeChecking/SelectLists.ag" #-} SelectList (ann_ ++ map TypeErrorA _errs ) _itemsIannotatedTree _intoIannotatedTree {-# LINE 8573 "AstInternal.hs" #-} -- "./TypeChecking/SelectLists.ag"(line 71, column 9) _lhsOlibUpdates = {-# LINE 71 "./TypeChecking/SelectLists.ag" #-} case _stuff of (_,Just r) -> [LibStackIDs [("", [r])]] _ -> [] {-# LINE 8580 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} SelectList ann_ _itemsIannotatedTree _intoIannotatedTree {-# LINE 8585 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} SelectList ann_ _itemsIoriginalTree _intoIoriginalTree {-# LINE 8590 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 8595 "AstInternal.hs" #-} -- copy rule (down) _itemsOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 8600 "AstInternal.hs" #-} -- copy rule (down) _itemsOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 8605 "AstInternal.hs" #-} -- copy rule (down) _intoOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 8610 "AstInternal.hs" #-} -- copy rule (down) _intoOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 8615 "AstInternal.hs" #-} ( _itemsIannotatedTree,_itemsIlistType,_itemsIoriginalTree) = (items_ _itemsOenv _itemsOlib ) ( _intoIannotatedTree,_intoIoriginalTree,_intoIstrings) = (into_ _intoOenv _intoOlib ) in ( _lhsOannotatedTree,_lhsOlibUpdates,_lhsOlistType,_lhsOoriginalTree))) -- SetClause --------------------------------------------------- {- visit 0: inherited attributes: env : Environment lib : LocalIdentifierBindings synthesized attributes: annotatedTree : SELF originalTree : SELF pairs : [(String,Type)] rowSetError : Maybe TypeError alternatives: alternative RowSetClause: child ann : {Annotation} child atts : StringList child vals : ExpressionList visit 0: local rowSetError : _ local annotatedTree : _ local originalTree : _ alternative SetClause: child ann : {Annotation} child att : {String} child val : Expression visit 0: local annotatedTree : _ local originalTree : _ -} data SetClause = RowSetClause (Annotation) (StringList) (ExpressionList) | SetClause (Annotation) (String) (Expression) deriving ( Data,Eq,Show,Typeable) -- cata sem_SetClause :: SetClause -> T_SetClause sem_SetClause (RowSetClause _ann _atts _vals ) = (sem_SetClause_RowSetClause _ann (sem_StringList _atts ) (sem_ExpressionList _vals ) ) sem_SetClause (SetClause _ann _att _val ) = (sem_SetClause_SetClause _ann _att (sem_Expression _val ) ) -- semantic domain type T_SetClause = Environment -> LocalIdentifierBindings -> ( SetClause,SetClause,([(String,Type)]),(Maybe TypeError)) data Inh_SetClause = Inh_SetClause {env_Inh_SetClause :: Environment,lib_Inh_SetClause :: LocalIdentifierBindings} data Syn_SetClause = Syn_SetClause {annotatedTree_Syn_SetClause :: SetClause,originalTree_Syn_SetClause :: SetClause,pairs_Syn_SetClause :: [(String,Type)],rowSetError_Syn_SetClause :: Maybe TypeError} wrap_SetClause :: T_SetClause -> Inh_SetClause -> Syn_SetClause wrap_SetClause sem (Inh_SetClause _lhsIenv _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree,_lhsOpairs,_lhsOrowSetError) = (sem _lhsIenv _lhsIlib ) in (Syn_SetClause _lhsOannotatedTree _lhsOoriginalTree _lhsOpairs _lhsOrowSetError )) sem_SetClause_RowSetClause :: Annotation -> T_StringList -> T_ExpressionList -> T_SetClause sem_SetClause_RowSetClause ann_ atts_ vals_ = (\ _lhsIenv _lhsIlib -> (let _lhsOpairs :: ([(String,Type)]) _lhsOannotatedTree :: SetClause _lhsOoriginalTree :: SetClause _lhsOrowSetError :: (Maybe TypeError) _attsOenv :: Environment _attsOlib :: LocalIdentifierBindings _valsOenv :: Environment _valsOlib :: LocalIdentifierBindings _attsIannotatedTree :: StringList _attsIoriginalTree :: StringList _attsIstrings :: ([String]) _valsIannotatedTree :: ExpressionList _valsIoriginalTree :: ExpressionList _valsItypeList :: ([Type]) -- "./TypeChecking/Dml.ag"(line 128, column 9) _rowSetError = {-# LINE 128 "./TypeChecking/Dml.ag" #-} let atts = _attsIstrings types = getRowTypes _valsItypeList in if length atts /= length types then Just WrongNumberOfColumns else Nothing {-# LINE 8701 "AstInternal.hs" #-} -- "./TypeChecking/Dml.ag"(line 134, column 9) _lhsOpairs = {-# LINE 134 "./TypeChecking/Dml.ag" #-} zip _attsIstrings $ getRowTypes _valsItypeList {-# LINE 8706 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} RowSetClause ann_ _attsIannotatedTree _valsIannotatedTree {-# LINE 8711 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} RowSetClause ann_ _attsIoriginalTree _valsIoriginalTree {-# LINE 8716 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 8721 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 8726 "AstInternal.hs" #-} -- copy rule (from local) _lhsOrowSetError = {-# LINE 121 "./TypeChecking/Dml.ag" #-} _rowSetError {-# LINE 8731 "AstInternal.hs" #-} -- copy rule (down) _attsOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 8736 "AstInternal.hs" #-} -- copy rule (down) _attsOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 8741 "AstInternal.hs" #-} -- copy rule (down) _valsOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 8746 "AstInternal.hs" #-} -- copy rule (down) _valsOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 8751 "AstInternal.hs" #-} ( _attsIannotatedTree,_attsIoriginalTree,_attsIstrings) = (atts_ _attsOenv _attsOlib ) ( _valsIannotatedTree,_valsIoriginalTree,_valsItypeList) = (vals_ _valsOenv _valsOlib ) in ( _lhsOannotatedTree,_lhsOoriginalTree,_lhsOpairs,_lhsOrowSetError))) sem_SetClause_SetClause :: Annotation -> String -> T_Expression -> T_SetClause sem_SetClause_SetClause ann_ att_ val_ = (\ _lhsIenv _lhsIlib -> (let _lhsOpairs :: ([(String,Type)]) _lhsOrowSetError :: (Maybe TypeError) _lhsOannotatedTree :: SetClause _lhsOoriginalTree :: SetClause _valOenv :: Environment _valOlib :: LocalIdentifierBindings _valIannotatedTree :: Expression _valIliftedColumnName :: String _valIoriginalTree :: Expression -- "./TypeChecking/Dml.ag"(line 125, column 9) _lhsOpairs = {-# LINE 125 "./TypeChecking/Dml.ag" #-} [(att_, getTypeAnnotation _valIannotatedTree)] {-# LINE 8777 "AstInternal.hs" #-} -- "./TypeChecking/Dml.ag"(line 126, column 9) _lhsOrowSetError = {-# LINE 126 "./TypeChecking/Dml.ag" #-} Nothing {-# LINE 8782 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} SetClause ann_ att_ _valIannotatedTree {-# LINE 8787 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} SetClause ann_ att_ _valIoriginalTree {-# LINE 8792 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 8797 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 8802 "AstInternal.hs" #-} -- copy rule (down) _valOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 8807 "AstInternal.hs" #-} -- copy rule (down) _valOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 8812 "AstInternal.hs" #-} ( _valIannotatedTree,_valIliftedColumnName,_valIoriginalTree) = (val_ _valOenv _valOlib ) in ( _lhsOannotatedTree,_lhsOoriginalTree,_lhsOpairs,_lhsOrowSetError))) -- SetClauseList ----------------------------------------------- {- visit 0: inherited attributes: env : Environment lib : LocalIdentifierBindings synthesized attributes: annotatedTree : SELF originalTree : SELF pairs : [(String,Type)] rowSetErrors : [TypeError] alternatives: alternative Cons: child hd : SetClause child tl : SetClauseList visit 0: local annotatedTree : _ local originalTree : _ alternative Nil: visit 0: local annotatedTree : _ local originalTree : _ -} type SetClauseList = [(SetClause)] -- cata sem_SetClauseList :: SetClauseList -> T_SetClauseList sem_SetClauseList list = (Prelude.foldr sem_SetClauseList_Cons sem_SetClauseList_Nil (Prelude.map sem_SetClause list) ) -- semantic domain type T_SetClauseList = Environment -> LocalIdentifierBindings -> ( SetClauseList,SetClauseList,([(String,Type)]),([TypeError])) data Inh_SetClauseList = Inh_SetClauseList {env_Inh_SetClauseList :: Environment,lib_Inh_SetClauseList :: LocalIdentifierBindings} data Syn_SetClauseList = Syn_SetClauseList {annotatedTree_Syn_SetClauseList :: SetClauseList,originalTree_Syn_SetClauseList :: SetClauseList,pairs_Syn_SetClauseList :: [(String,Type)],rowSetErrors_Syn_SetClauseList :: [TypeError]} wrap_SetClauseList :: T_SetClauseList -> Inh_SetClauseList -> Syn_SetClauseList wrap_SetClauseList sem (Inh_SetClauseList _lhsIenv _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree,_lhsOpairs,_lhsOrowSetErrors) = (sem _lhsIenv _lhsIlib ) in (Syn_SetClauseList _lhsOannotatedTree _lhsOoriginalTree _lhsOpairs _lhsOrowSetErrors )) sem_SetClauseList_Cons :: T_SetClause -> T_SetClauseList -> T_SetClauseList sem_SetClauseList_Cons hd_ tl_ = (\ _lhsIenv _lhsIlib -> (let _lhsOpairs :: ([(String,Type)]) _lhsOrowSetErrors :: ([TypeError]) _lhsOannotatedTree :: SetClauseList _lhsOoriginalTree :: SetClauseList _hdOenv :: Environment _hdOlib :: LocalIdentifierBindings _tlOenv :: Environment _tlOlib :: LocalIdentifierBindings _hdIannotatedTree :: SetClause _hdIoriginalTree :: SetClause _hdIpairs :: ([(String,Type)]) _hdIrowSetError :: (Maybe TypeError) _tlIannotatedTree :: SetClauseList _tlIoriginalTree :: SetClauseList _tlIpairs :: ([(String,Type)]) _tlIrowSetErrors :: ([TypeError]) -- "./TypeChecking/Dml.ag"(line 115, column 10) _lhsOpairs = {-# LINE 115 "./TypeChecking/Dml.ag" #-} _hdIpairs ++ _tlIpairs {-# LINE 8884 "AstInternal.hs" #-} -- "./TypeChecking/Dml.ag"(line 116, column 10) _lhsOrowSetErrors = {-# LINE 116 "./TypeChecking/Dml.ag" #-} maybeToList _hdIrowSetError ++ _tlIrowSetErrors {-# LINE 8889 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} (:) _hdIannotatedTree _tlIannotatedTree {-# LINE 8894 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} (:) _hdIoriginalTree _tlIoriginalTree {-# LINE 8899 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 8904 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 8909 "AstInternal.hs" #-} -- copy rule (down) _hdOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 8914 "AstInternal.hs" #-} -- copy rule (down) _hdOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 8919 "AstInternal.hs" #-} -- copy rule (down) _tlOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 8924 "AstInternal.hs" #-} -- copy rule (down) _tlOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 8929 "AstInternal.hs" #-} ( _hdIannotatedTree,_hdIoriginalTree,_hdIpairs,_hdIrowSetError) = (hd_ _hdOenv _hdOlib ) ( _tlIannotatedTree,_tlIoriginalTree,_tlIpairs,_tlIrowSetErrors) = (tl_ _tlOenv _tlOlib ) in ( _lhsOannotatedTree,_lhsOoriginalTree,_lhsOpairs,_lhsOrowSetErrors))) sem_SetClauseList_Nil :: T_SetClauseList sem_SetClauseList_Nil = (\ _lhsIenv _lhsIlib -> (let _lhsOpairs :: ([(String,Type)]) _lhsOrowSetErrors :: ([TypeError]) _lhsOannotatedTree :: SetClauseList _lhsOoriginalTree :: SetClauseList -- "./TypeChecking/Dml.ag"(line 117, column 9) _lhsOpairs = {-# LINE 117 "./TypeChecking/Dml.ag" #-} [] {-# LINE 8947 "AstInternal.hs" #-} -- "./TypeChecking/Dml.ag"(line 118, column 9) _lhsOrowSetErrors = {-# LINE 118 "./TypeChecking/Dml.ag" #-} [] {-# LINE 8952 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 8957 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 8962 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 8967 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 8972 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree,_lhsOpairs,_lhsOrowSetErrors))) -- SetValue ---------------------------------------------------- {- visit 0: inherited attributes: env : Environment lib : LocalIdentifierBindings synthesized attributes: annotatedTree : SELF originalTree : SELF alternatives: alternative SetId: child ann : {Annotation} child string : {String} visit 0: local annotatedTree : _ local originalTree : _ alternative SetNum: child ann : {Annotation} child double : {Double} visit 0: local annotatedTree : _ local originalTree : _ alternative SetStr: child ann : {Annotation} child string : {String} visit 0: local annotatedTree : _ local originalTree : _ -} data SetValue = SetId (Annotation) (String) | SetNum (Annotation) (Double) | SetStr (Annotation) (String) deriving ( Data,Eq,Show,Typeable) -- cata sem_SetValue :: SetValue -> T_SetValue sem_SetValue (SetId _ann _string ) = (sem_SetValue_SetId _ann _string ) sem_SetValue (SetNum _ann _double ) = (sem_SetValue_SetNum _ann _double ) sem_SetValue (SetStr _ann _string ) = (sem_SetValue_SetStr _ann _string ) -- semantic domain type T_SetValue = Environment -> LocalIdentifierBindings -> ( SetValue,SetValue) data Inh_SetValue = Inh_SetValue {env_Inh_SetValue :: Environment,lib_Inh_SetValue :: LocalIdentifierBindings} data Syn_SetValue = Syn_SetValue {annotatedTree_Syn_SetValue :: SetValue,originalTree_Syn_SetValue :: SetValue} wrap_SetValue :: T_SetValue -> Inh_SetValue -> Syn_SetValue wrap_SetValue sem (Inh_SetValue _lhsIenv _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIenv _lhsIlib ) in (Syn_SetValue _lhsOannotatedTree _lhsOoriginalTree )) sem_SetValue_SetId :: Annotation -> String -> T_SetValue sem_SetValue_SetId ann_ string_ = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: SetValue _lhsOoriginalTree :: SetValue -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} SetId ann_ string_ {-# LINE 9041 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} SetId ann_ string_ {-# LINE 9046 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 9051 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 9056 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_SetValue_SetNum :: Annotation -> Double -> T_SetValue sem_SetValue_SetNum ann_ double_ = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: SetValue _lhsOoriginalTree :: SetValue -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} SetNum ann_ double_ {-# LINE 9070 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} SetNum ann_ double_ {-# LINE 9075 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 9080 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 9085 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_SetValue_SetStr :: Annotation -> String -> T_SetValue sem_SetValue_SetStr ann_ string_ = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: SetValue _lhsOoriginalTree :: SetValue -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} SetStr ann_ string_ {-# LINE 9099 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} SetStr ann_ string_ {-# LINE 9104 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 9109 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 9114 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) -- Statement --------------------------------------------------- {- visit 0: inherited attributes: env : Environment inProducedEnv : Environment lib : LocalIdentifierBindings synthesized attributes: annotatedTree : SELF envUpdates : [EnvironmentUpdate] libUpdates : [LocalIdentifierBindingsUpdate] originalTree : SELF alternatives: alternative AlterSequence: child ann : {Annotation} child name : {String} child ownedBy : {String} visit 0: local libUpdates : _ local annotatedTree : _ local originalTree : _ alternative AlterTable: child ann : {Annotation} child name : {String} child actions : {[AlterTableAction]} visit 0: local annotatedTree : _ local originalTree : _ alternative Assignment: child ann : {Annotation} child target : {String} child value : Expression visit 0: local libUpdates : _ local tpe : {Either [TypeError] Type} local backTree : _ local envUpdates : {[EnvironmentUpdate]} local statementType : _ local annotatedTree : _ local originalTree : _ alternative CaseStatement: child ann : {Annotation} child val : Expression child cases : ExpressionListStatementListPairList child els : StatementList visit 0: local annotatedTree : _ local originalTree : _ alternative ContinueStatement: child ann : {Annotation} visit 0: local annotatedTree : _ local originalTree : _ alternative Copy: child ann : {Annotation} child table : {String} child targetCols : StringList child source : CopySource visit 0: local annotatedTree : _ local originalTree : _ alternative CopyData: child ann : {Annotation} child insData : {String} visit 0: local annotatedTree : _ local originalTree : _ alternative CreateDomain: child ann : {Annotation} child name : {String} child typ : TypeName child checkName : {String} child check : MaybeBoolExpression visit 0: local libUpdates : _ local tpe : {Either [TypeError] Type} local backTree : _ local statementType : _ local envUpdates : {[EnvironmentUpdate]} local annotatedTree : _ local originalTree : _ alternative CreateFunction: child ann : {Annotation} child name : {String} child params : ParamDefList child rettype : TypeName child lang : Language child bodyQuote : {String} child body : FnBody child vol : Volatility visit 0: local libUpdates : _ local tpe : {Either [TypeError] Type} local envUpdates : {[EnvironmentUpdate]} local parameterTypes : _ local backTree : _ local statementType : _ local annotatedTree : _ local originalTree : _ alternative CreateLanguage: child ann : {Annotation} child name : {String} visit 0: local libUpdates : _ local annotatedTree : _ local originalTree : _ alternative CreateSequence: child ann : {Annotation} child name : {String} child incr : {Integer} child min : {Integer} child max : {Integer} child start : {Integer} child cache : {Integer} visit 0: local libUpdates : _ local annotatedTree : _ local originalTree : _ alternative CreateTable: child ann : {Annotation} child name : {String} child atts : AttributeDefList child cons : ConstraintList visit 0: local libUpdates : _ local tpe : {Either [TypeError] Type} local envUpdates : {[EnvironmentUpdate]} local attrTypes : {[Type]} local statementType : _ local backTree : _ local annotatedTree : _ local originalTree : _ alternative CreateTableAs: child ann : {Annotation} child name : {String} child expr : SelectExpression visit 0: local libUpdates : _ local tpe : {Either [TypeError] Type} local envUpdates : {[EnvironmentUpdate]} local selType : _ local attrs : _ local backTree : _ local statementType : _ local annotatedTree : _ local originalTree : _ alternative CreateTrigger: child ann : {Annotation} child name : {String} child wh : TriggerWhen child events : {[TriggerEvent]} child tbl : {String} child firing : TriggerFire child fnName : {String} child fnArgs : {[Expression]} visit 0: local annotatedTree : _ local originalTree : _ alternative CreateType: child ann : {Annotation} child name : {String} child atts : TypeAttributeDefList visit 0: local libUpdates : _ local tpe : {Either [TypeError] Type} local backTree : _ local statementType : _ local envUpdates : {[EnvironmentUpdate]} local annotatedTree : _ local originalTree : _ alternative CreateView: child ann : {Annotation} child name : {String} child expr : SelectExpression visit 0: local libUpdates : _ local tpe : {Either [TypeError] Type} local backTree : _ local attrs : _ local envUpdates : {[EnvironmentUpdate]} local statementType : _ local annotatedTree : _ local originalTree : _ alternative Delete: child ann : {Annotation} child table : {String} child whr : MaybeBoolExpression child returning : MaybeSelectList visit 0: local libUpdates : _ local tpe : {Either [TypeError] Type} local statementType : _ local backTree : _ local envUpdates : {[EnvironmentUpdate]} local lib : _ local annotatedTree : _ local originalTree : _ alternative DropFunction: child ann : {Annotation} child ifE : IfExists child sigs : StringTypeNameListPairList child cascade : Cascade visit 0: local libUpdates : _ local tpe : {Either [TypeError] Type} local backTree : _ local envUpdates : {[EnvironmentUpdate]} local statementType : _ local annotatedTree : _ local originalTree : _ alternative DropSomething: child ann : {Annotation} child dropType : DropType child ifE : IfExists child names : StringList child cascade : Cascade visit 0: local annotatedTree : _ local originalTree : _ alternative Execute: child ann : {Annotation} child expr : Expression visit 0: local annotatedTree : _ local originalTree : _ alternative ExecuteInto: child ann : {Annotation} child expr : Expression child targets : StringList visit 0: local annotatedTree : _ local originalTree : _ alternative ForIntegerStatement: child ann : {Annotation} child var : {String} child from : Expression child to : Expression child sts : StatementList visit 0: local libUpdates : _ local varTypeE : _ local tpe : {Either [TypeError] Type} local backTree : _ local envUpdates : {[EnvironmentUpdate]} local statementType : _ local annotatedTree : _ local originalTree : _ alternative ForSelectStatement: child ann : {Annotation} child var : {String} child sel : SelectExpression child sts : StatementList visit 0: local libUpdates : _ local selType : _ local tpe : {Either [TypeError] Type} local backTree : _ local envUpdates : {[EnvironmentUpdate]} local statementType : _ local annotatedTree : _ local originalTree : _ alternative If: child ann : {Annotation} child cases : ExpressionStatementListPairList child els : StatementList visit 0: local annotatedTree : _ local originalTree : _ alternative Insert: child ann : {Annotation} child table : {String} child targetCols : StringList child insData : SelectExpression child returning : MaybeSelectList visit 0: local libUpdates : _ local tpe : {Either [TypeError] Type} local statementType : _ local columnTypes : _ local backTree : _ local envUpdates : {[EnvironmentUpdate]} local annotatedTree : _ local originalTree : _ alternative Notify: child ann : {Annotation} child name : {String} visit 0: local libUpdates : _ local annotatedTree : _ local originalTree : _ alternative NullStatement: child ann : {Annotation} visit 0: local annotatedTree : _ local originalTree : _ alternative Perform: child ann : {Annotation} child expr : Expression visit 0: local annotatedTree : _ local originalTree : _ alternative Raise: child ann : {Annotation} child level : RaiseType child message : {String} child args : ExpressionList visit 0: local annotatedTree : _ local originalTree : _ alternative Return: child ann : {Annotation} child value : MaybeExpression visit 0: local libUpdates : _ local tpe : {Either [TypeError] Type} local backTree : _ local envUpdates : {[EnvironmentUpdate]} local statementType : _ local annotatedTree : _ local originalTree : _ alternative ReturnNext: child ann : {Annotation} child expr : Expression visit 0: local annotatedTree : _ local originalTree : _ alternative ReturnQuery: child ann : {Annotation} child sel : SelectExpression visit 0: local annotatedTree : _ local originalTree : _ alternative SelectStatement: child ann : {Annotation} child ex : SelectExpression visit 0: local tpe : {Either [TypeError] Type} local statementType : _ local backTree : _ local envUpdates : {[EnvironmentUpdate]} local libUpdates : _ local annotatedTree : _ local originalTree : _ alternative Set: child ann : {Annotation} child name : {String} child values : {[SetValue]} visit 0: local libUpdates : _ local annotatedTree : _ local originalTree : _ alternative Truncate: child ann : {Annotation} child tables : StringList child restartIdentity : RestartIdentity child cascade : Cascade visit 0: local annotatedTree : _ local originalTree : _ alternative Update: child ann : {Annotation} child table : {String} child assigns : SetClauseList child whr : MaybeBoolExpression child returning : MaybeSelectList visit 0: local libUpdates : _ local tpe : {Either [TypeError] Type} local statementType : _ local columnTypes : _ local backTree : _ local envUpdates : {[EnvironmentUpdate]} local lib : _ local annotatedTree : _ local originalTree : _ alternative WhileStatement: child ann : {Annotation} child expr : Expression child sts : StatementList visit 0: local annotatedTree : _ local originalTree : _ -} data Statement = AlterSequence (Annotation) (String) (String) | AlterTable (Annotation) (String) ([AlterTableAction]) | Assignment (Annotation) (String) (Expression) | CaseStatement (Annotation) (Expression) (ExpressionListStatementListPairList) (StatementList) | ContinueStatement (Annotation) | Copy (Annotation) (String) (StringList) (CopySource) | CopyData (Annotation) (String) | CreateDomain (Annotation) (String) (TypeName) (String) (MaybeBoolExpression) | CreateFunction (Annotation) (String) (ParamDefList) (TypeName) (Language) (String) (FnBody) (Volatility) | CreateLanguage (Annotation) (String) | CreateSequence (Annotation) (String) (Integer) (Integer) (Integer) (Integer) (Integer) | CreateTable (Annotation) (String) (AttributeDefList) (ConstraintList) | CreateTableAs (Annotation) (String) (SelectExpression) | CreateTrigger (Annotation) (String) (TriggerWhen) ([TriggerEvent]) (String) (TriggerFire) (String) ([Expression]) | CreateType (Annotation) (String) (TypeAttributeDefList) | CreateView (Annotation) (String) (SelectExpression) | Delete (Annotation) (String) (MaybeBoolExpression) (MaybeSelectList) | DropFunction (Annotation) (IfExists) (StringTypeNameListPairList) (Cascade) | DropSomething (Annotation) (DropType) (IfExists) (StringList) (Cascade) | Execute (Annotation) (Expression) | ExecuteInto (Annotation) (Expression) (StringList) | ForIntegerStatement (Annotation) (String) (Expression) (Expression) (StatementList) | ForSelectStatement (Annotation) (String) (SelectExpression) (StatementList) | If (Annotation) (ExpressionStatementListPairList) (StatementList) | Insert (Annotation) (String) (StringList) (SelectExpression) (MaybeSelectList) | Notify (Annotation) (String) | NullStatement (Annotation) | Perform (Annotation) (Expression) | Raise (Annotation) (RaiseType) (String) (ExpressionList) | Return (Annotation) (MaybeExpression) | ReturnNext (Annotation) (Expression) | ReturnQuery (Annotation) (SelectExpression) | SelectStatement (Annotation) (SelectExpression) | Set (Annotation) (String) ([SetValue]) | Truncate (Annotation) (StringList) (RestartIdentity) (Cascade) | Update (Annotation) (String) (SetClauseList) (MaybeBoolExpression) (MaybeSelectList) | WhileStatement (Annotation) (Expression) (StatementList) deriving ( Data,Eq,Show,Typeable) -- cata sem_Statement :: Statement -> T_Statement sem_Statement (AlterSequence _ann _name _ownedBy ) = (sem_Statement_AlterSequence _ann _name _ownedBy ) sem_Statement (AlterTable _ann _name _actions ) = (sem_Statement_AlterTable _ann _name _actions ) sem_Statement (Assignment _ann _target _value ) = (sem_Statement_Assignment _ann _target (sem_Expression _value ) ) sem_Statement (CaseStatement _ann _val _cases _els ) = (sem_Statement_CaseStatement _ann (sem_Expression _val ) (sem_ExpressionListStatementListPairList _cases ) (sem_StatementList _els ) ) sem_Statement (ContinueStatement _ann ) = (sem_Statement_ContinueStatement _ann ) sem_Statement (Copy _ann _table _targetCols _source ) = (sem_Statement_Copy _ann _table (sem_StringList _targetCols ) (sem_CopySource _source ) ) sem_Statement (CopyData _ann _insData ) = (sem_Statement_CopyData _ann _insData ) sem_Statement (CreateDomain _ann _name _typ _checkName _check ) = (sem_Statement_CreateDomain _ann _name (sem_TypeName _typ ) _checkName (sem_MaybeBoolExpression _check ) ) sem_Statement (CreateFunction _ann _name _params _rettype _lang _bodyQuote _body _vol ) = (sem_Statement_CreateFunction _ann _name (sem_ParamDefList _params ) (sem_TypeName _rettype ) (sem_Language _lang ) _bodyQuote (sem_FnBody _body ) (sem_Volatility _vol ) ) sem_Statement (CreateLanguage _ann _name ) = (sem_Statement_CreateLanguage _ann _name ) sem_Statement (CreateSequence _ann _name _incr _min _max _start _cache ) = (sem_Statement_CreateSequence _ann _name _incr _min _max _start _cache ) sem_Statement (CreateTable _ann _name _atts _cons ) = (sem_Statement_CreateTable _ann _name (sem_AttributeDefList _atts ) (sem_ConstraintList _cons ) ) sem_Statement (CreateTableAs _ann _name _expr ) = (sem_Statement_CreateTableAs _ann _name (sem_SelectExpression _expr ) ) sem_Statement (CreateTrigger _ann _name _wh _events _tbl _firing _fnName _fnArgs ) = (sem_Statement_CreateTrigger _ann _name (sem_TriggerWhen _wh ) _events _tbl (sem_TriggerFire _firing ) _fnName _fnArgs ) sem_Statement (CreateType _ann _name _atts ) = (sem_Statement_CreateType _ann _name (sem_TypeAttributeDefList _atts ) ) sem_Statement (CreateView _ann _name _expr ) = (sem_Statement_CreateView _ann _name (sem_SelectExpression _expr ) ) sem_Statement (Delete _ann _table _whr _returning ) = (sem_Statement_Delete _ann _table (sem_MaybeBoolExpression _whr ) (sem_MaybeSelectList _returning ) ) sem_Statement (DropFunction _ann _ifE _sigs _cascade ) = (sem_Statement_DropFunction _ann (sem_IfExists _ifE ) (sem_StringTypeNameListPairList _sigs ) (sem_Cascade _cascade ) ) sem_Statement (DropSomething _ann _dropType _ifE _names _cascade ) = (sem_Statement_DropSomething _ann (sem_DropType _dropType ) (sem_IfExists _ifE ) (sem_StringList _names ) (sem_Cascade _cascade ) ) sem_Statement (Execute _ann _expr ) = (sem_Statement_Execute _ann (sem_Expression _expr ) ) sem_Statement (ExecuteInto _ann _expr _targets ) = (sem_Statement_ExecuteInto _ann (sem_Expression _expr ) (sem_StringList _targets ) ) sem_Statement (ForIntegerStatement _ann _var _from _to _sts ) = (sem_Statement_ForIntegerStatement _ann _var (sem_Expression _from ) (sem_Expression _to ) (sem_StatementList _sts ) ) sem_Statement (ForSelectStatement _ann _var _sel _sts ) = (sem_Statement_ForSelectStatement _ann _var (sem_SelectExpression _sel ) (sem_StatementList _sts ) ) sem_Statement (If _ann _cases _els ) = (sem_Statement_If _ann (sem_ExpressionStatementListPairList _cases ) (sem_StatementList _els ) ) sem_Statement (Insert _ann _table _targetCols _insData _returning ) = (sem_Statement_Insert _ann _table (sem_StringList _targetCols ) (sem_SelectExpression _insData ) (sem_MaybeSelectList _returning ) ) sem_Statement (Notify _ann _name ) = (sem_Statement_Notify _ann _name ) sem_Statement (NullStatement _ann ) = (sem_Statement_NullStatement _ann ) sem_Statement (Perform _ann _expr ) = (sem_Statement_Perform _ann (sem_Expression _expr ) ) sem_Statement (Raise _ann _level _message _args ) = (sem_Statement_Raise _ann (sem_RaiseType _level ) _message (sem_ExpressionList _args ) ) sem_Statement (Return _ann _value ) = (sem_Statement_Return _ann (sem_MaybeExpression _value ) ) sem_Statement (ReturnNext _ann _expr ) = (sem_Statement_ReturnNext _ann (sem_Expression _expr ) ) sem_Statement (ReturnQuery _ann _sel ) = (sem_Statement_ReturnQuery _ann (sem_SelectExpression _sel ) ) sem_Statement (SelectStatement _ann _ex ) = (sem_Statement_SelectStatement _ann (sem_SelectExpression _ex ) ) sem_Statement (Set _ann _name _values ) = (sem_Statement_Set _ann _name _values ) sem_Statement (Truncate _ann _tables _restartIdentity _cascade ) = (sem_Statement_Truncate _ann (sem_StringList _tables ) (sem_RestartIdentity _restartIdentity ) (sem_Cascade _cascade ) ) sem_Statement (Update _ann _table _assigns _whr _returning ) = (sem_Statement_Update _ann _table (sem_SetClauseList _assigns ) (sem_MaybeBoolExpression _whr ) (sem_MaybeSelectList _returning ) ) sem_Statement (WhileStatement _ann _expr _sts ) = (sem_Statement_WhileStatement _ann (sem_Expression _expr ) (sem_StatementList _sts ) ) -- semantic domain type T_Statement = Environment -> Environment -> LocalIdentifierBindings -> ( Statement,([EnvironmentUpdate]),([LocalIdentifierBindingsUpdate]),Statement) data Inh_Statement = Inh_Statement {env_Inh_Statement :: Environment,inProducedEnv_Inh_Statement :: Environment,lib_Inh_Statement :: LocalIdentifierBindings} data Syn_Statement = Syn_Statement {annotatedTree_Syn_Statement :: Statement,envUpdates_Syn_Statement :: [EnvironmentUpdate],libUpdates_Syn_Statement :: [LocalIdentifierBindingsUpdate],originalTree_Syn_Statement :: Statement} wrap_Statement :: T_Statement -> Inh_Statement -> Syn_Statement wrap_Statement sem (Inh_Statement _lhsIenv _lhsIinProducedEnv _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOenvUpdates,_lhsOlibUpdates,_lhsOoriginalTree) = (sem _lhsIenv _lhsIinProducedEnv _lhsIlib ) in (Syn_Statement _lhsOannotatedTree _lhsOenvUpdates _lhsOlibUpdates _lhsOoriginalTree )) sem_Statement_AlterSequence :: Annotation -> String -> String -> T_Statement sem_Statement_AlterSequence ann_ name_ ownedBy_ = (\ _lhsIenv _lhsIinProducedEnv _lhsIlib -> (let _lhsOenvUpdates :: ([EnvironmentUpdate]) _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _lhsOannotatedTree :: Statement _lhsOoriginalTree :: Statement -- "./TypeChecking/Statements.ag"(line 73, column 9) _libUpdates = {-# LINE 73 "./TypeChecking/Statements.ag" #-} [] {-# LINE 9644 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 89, column 9) _lhsOenvUpdates = {-# LINE 89 "./TypeChecking/Statements.ag" #-} [] {-# LINE 9649 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 90, column 9) _lhsOlibUpdates = {-# LINE 90 "./TypeChecking/Statements.ag" #-} [] {-# LINE 9654 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} AlterSequence ann_ name_ ownedBy_ {-# LINE 9659 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} AlterSequence ann_ name_ ownedBy_ {-# LINE 9664 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 9669 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 9674 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOenvUpdates,_lhsOlibUpdates,_lhsOoriginalTree))) sem_Statement_AlterTable :: Annotation -> String -> ([AlterTableAction]) -> T_Statement sem_Statement_AlterTable ann_ name_ actions_ = (\ _lhsIenv _lhsIinProducedEnv _lhsIlib -> (let _lhsOenvUpdates :: ([EnvironmentUpdate]) _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _lhsOannotatedTree :: Statement _lhsOoriginalTree :: Statement -- "./TypeChecking/Statements.ag"(line 89, column 9) _lhsOenvUpdates = {-# LINE 89 "./TypeChecking/Statements.ag" #-} [] {-# LINE 9692 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 90, column 9) _lhsOlibUpdates = {-# LINE 90 "./TypeChecking/Statements.ag" #-} [] {-# LINE 9697 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} AlterTable ann_ name_ actions_ {-# LINE 9702 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} AlterTable ann_ name_ actions_ {-# LINE 9707 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 9712 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 9717 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOenvUpdates,_lhsOlibUpdates,_lhsOoriginalTree))) sem_Statement_Assignment :: Annotation -> String -> T_Expression -> T_Statement sem_Statement_Assignment ann_ target_ value_ = (\ _lhsIenv _lhsIinProducedEnv _lhsIlib -> (let _lhsOannotatedTree :: Statement _lhsOenvUpdates :: ([EnvironmentUpdate]) _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _tpe :: (Either [TypeError] Type) _envUpdates :: ([EnvironmentUpdate]) _lhsOoriginalTree :: Statement _valueOenv :: Environment _valueOlib :: LocalIdentifierBindings _valueIannotatedTree :: Expression _valueIliftedColumnName :: String _valueIoriginalTree :: Expression -- "./TypeChecking/Statements.ag"(line 61, column 9) _lhsOannotatedTree = {-# LINE 61 "./TypeChecking/Statements.ag" #-} annTypesAndErrors _backTree (tpeToT _tpe ) (getErrors _tpe ) $ Just (map StatementTypeA _statementType ++ [EnvUpdates _envUpdates ]) {-# LINE 9746 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 67, column 9) _lhsOenvUpdates = {-# LINE 67 "./TypeChecking/Statements.ag" #-} _envUpdates {-# LINE 9751 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 68, column 9) _lhsOlibUpdates = {-# LINE 68 "./TypeChecking/Statements.ag" #-} _libUpdates {-# LINE 9756 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 73, column 9) _libUpdates = {-# LINE 73 "./TypeChecking/Statements.ag" #-} [] {-# LINE 9761 "AstInternal.hs" #-} -- "./TypeChecking/Plpgsql.ag"(line 23, column 9) _tpe = {-# LINE 23 "./TypeChecking/Plpgsql.ag" #-} do let fromType = getTypeAnnotation _valueIannotatedTree toType <- libLookupID _lhsIlib target_ dependsOnRTpe [getTypeAnnotation _valueIannotatedTree, toType] $ do checkAssignmentValid _lhsIenv fromType toType return $ Pseudo Void {-# LINE 9771 "AstInternal.hs" #-} -- "./TypeChecking/Plpgsql.ag"(line 30, column 9) _backTree = {-# LINE 30 "./TypeChecking/Plpgsql.ag" #-} Assignment ann_ target_ _valueIannotatedTree {-# LINE 9776 "AstInternal.hs" #-} -- "./TypeChecking/Plpgsql.ag"(line 31, column 9) _envUpdates = {-# LINE 31 "./TypeChecking/Plpgsql.ag" #-} [] {-# LINE 9781 "AstInternal.hs" #-} -- "./TypeChecking/Plpgsql.ag"(line 32, column 9) _statementType = {-# LINE 32 "./TypeChecking/Plpgsql.ag" #-} [] {-# LINE 9786 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Assignment ann_ target_ _valueIannotatedTree {-# LINE 9791 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Assignment ann_ target_ _valueIoriginalTree {-# LINE 9796 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 9801 "AstInternal.hs" #-} -- copy rule (down) _valueOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 9806 "AstInternal.hs" #-} -- copy rule (down) _valueOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 9811 "AstInternal.hs" #-} ( _valueIannotatedTree,_valueIliftedColumnName,_valueIoriginalTree) = (value_ _valueOenv _valueOlib ) in ( _lhsOannotatedTree,_lhsOenvUpdates,_lhsOlibUpdates,_lhsOoriginalTree))) sem_Statement_CaseStatement :: Annotation -> T_Expression -> T_ExpressionListStatementListPairList -> T_StatementList -> T_Statement sem_Statement_CaseStatement ann_ val_ cases_ els_ = (\ _lhsIenv _lhsIinProducedEnv _lhsIlib -> (let _lhsOenvUpdates :: ([EnvironmentUpdate]) _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _elsOenvUpdates :: ([EnvironmentUpdate]) _elsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _lhsOannotatedTree :: Statement _lhsOoriginalTree :: Statement _valOenv :: Environment _valOlib :: LocalIdentifierBindings _casesOenv :: Environment _casesOlib :: LocalIdentifierBindings _elsOenv :: Environment _elsOlib :: LocalIdentifierBindings _valIannotatedTree :: Expression _valIliftedColumnName :: String _valIoriginalTree :: Expression _casesIannotatedTree :: ExpressionListStatementListPairList _casesIoriginalTree :: ExpressionListStatementListPairList _elsIannotatedTree :: StatementList _elsIoriginalTree :: StatementList _elsIproducedEnv :: Environment _elsIproducedLib :: LocalIdentifierBindings -- "./TypeChecking/Statements.ag"(line 89, column 9) _lhsOenvUpdates = {-# LINE 89 "./TypeChecking/Statements.ag" #-} [] {-# LINE 9849 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 90, column 9) _lhsOlibUpdates = {-# LINE 90 "./TypeChecking/Statements.ag" #-} [] {-# LINE 9854 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 106, column 9) _elsOenvUpdates = {-# LINE 106 "./TypeChecking/Statements.ag" #-} [] {-# LINE 9859 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 107, column 9) _elsOlibUpdates = {-# LINE 107 "./TypeChecking/Statements.ag" #-} [] {-# LINE 9864 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} CaseStatement ann_ _valIannotatedTree _casesIannotatedTree _elsIannotatedTree {-# LINE 9869 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} CaseStatement ann_ _valIoriginalTree _casesIoriginalTree _elsIoriginalTree {-# LINE 9874 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 9879 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 9884 "AstInternal.hs" #-} -- copy rule (down) _valOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 9889 "AstInternal.hs" #-} -- copy rule (down) _valOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 9894 "AstInternal.hs" #-} -- copy rule (down) _casesOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 9899 "AstInternal.hs" #-} -- copy rule (down) _casesOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 9904 "AstInternal.hs" #-} -- copy rule (down) _elsOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 9909 "AstInternal.hs" #-} -- copy rule (down) _elsOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 9914 "AstInternal.hs" #-} ( _valIannotatedTree,_valIliftedColumnName,_valIoriginalTree) = (val_ _valOenv _valOlib ) ( _casesIannotatedTree,_casesIoriginalTree) = (cases_ _casesOenv _casesOlib ) ( _elsIannotatedTree,_elsIoriginalTree,_elsIproducedEnv,_elsIproducedLib) = (els_ _elsOenv _elsOenvUpdates _elsOlib _elsOlibUpdates ) in ( _lhsOannotatedTree,_lhsOenvUpdates,_lhsOlibUpdates,_lhsOoriginalTree))) sem_Statement_ContinueStatement :: Annotation -> T_Statement sem_Statement_ContinueStatement ann_ = (\ _lhsIenv _lhsIinProducedEnv _lhsIlib -> (let _lhsOenvUpdates :: ([EnvironmentUpdate]) _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _lhsOannotatedTree :: Statement _lhsOoriginalTree :: Statement -- "./TypeChecking/Statements.ag"(line 89, column 9) _lhsOenvUpdates = {-# LINE 89 "./TypeChecking/Statements.ag" #-} [] {-# LINE 9936 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 90, column 9) _lhsOlibUpdates = {-# LINE 90 "./TypeChecking/Statements.ag" #-} [] {-# LINE 9941 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} ContinueStatement ann_ {-# LINE 9946 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} ContinueStatement ann_ {-# LINE 9951 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 9956 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 9961 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOenvUpdates,_lhsOlibUpdates,_lhsOoriginalTree))) sem_Statement_Copy :: Annotation -> String -> T_StringList -> T_CopySource -> T_Statement sem_Statement_Copy ann_ table_ targetCols_ source_ = (\ _lhsIenv _lhsIinProducedEnv _lhsIlib -> (let _lhsOenvUpdates :: ([EnvironmentUpdate]) _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _lhsOannotatedTree :: Statement _lhsOoriginalTree :: Statement _targetColsOenv :: Environment _targetColsOlib :: LocalIdentifierBindings _sourceOenv :: Environment _sourceOlib :: LocalIdentifierBindings _targetColsIannotatedTree :: StringList _targetColsIoriginalTree :: StringList _targetColsIstrings :: ([String]) _sourceIannotatedTree :: CopySource _sourceIoriginalTree :: CopySource -- "./TypeChecking/Statements.ag"(line 89, column 9) _lhsOenvUpdates = {-# LINE 89 "./TypeChecking/Statements.ag" #-} [] {-# LINE 9989 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 90, column 9) _lhsOlibUpdates = {-# LINE 90 "./TypeChecking/Statements.ag" #-} [] {-# LINE 9994 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Copy ann_ table_ _targetColsIannotatedTree _sourceIannotatedTree {-# LINE 9999 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Copy ann_ table_ _targetColsIoriginalTree _sourceIoriginalTree {-# LINE 10004 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 10009 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 10014 "AstInternal.hs" #-} -- copy rule (down) _targetColsOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 10019 "AstInternal.hs" #-} -- copy rule (down) _targetColsOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 10024 "AstInternal.hs" #-} -- copy rule (down) _sourceOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 10029 "AstInternal.hs" #-} -- copy rule (down) _sourceOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 10034 "AstInternal.hs" #-} ( _targetColsIannotatedTree,_targetColsIoriginalTree,_targetColsIstrings) = (targetCols_ _targetColsOenv _targetColsOlib ) ( _sourceIannotatedTree,_sourceIoriginalTree) = (source_ _sourceOenv _sourceOlib ) in ( _lhsOannotatedTree,_lhsOenvUpdates,_lhsOlibUpdates,_lhsOoriginalTree))) sem_Statement_CopyData :: Annotation -> String -> T_Statement sem_Statement_CopyData ann_ insData_ = (\ _lhsIenv _lhsIinProducedEnv _lhsIlib -> (let _lhsOenvUpdates :: ([EnvironmentUpdate]) _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _lhsOannotatedTree :: Statement _lhsOoriginalTree :: Statement -- "./TypeChecking/Statements.ag"(line 89, column 9) _lhsOenvUpdates = {-# LINE 89 "./TypeChecking/Statements.ag" #-} [] {-# LINE 10055 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 90, column 9) _lhsOlibUpdates = {-# LINE 90 "./TypeChecking/Statements.ag" #-} [] {-# LINE 10060 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} CopyData ann_ insData_ {-# LINE 10065 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} CopyData ann_ insData_ {-# LINE 10070 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 10075 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 10080 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOenvUpdates,_lhsOlibUpdates,_lhsOoriginalTree))) sem_Statement_CreateDomain :: Annotation -> String -> T_TypeName -> String -> T_MaybeBoolExpression -> T_Statement sem_Statement_CreateDomain ann_ name_ typ_ checkName_ check_ = (\ _lhsIenv _lhsIinProducedEnv _lhsIlib -> (let _lhsOannotatedTree :: Statement _lhsOenvUpdates :: ([EnvironmentUpdate]) _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _tpe :: (Either [TypeError] Type) _envUpdates :: ([EnvironmentUpdate]) _checkOlib :: LocalIdentifierBindings _lhsOoriginalTree :: Statement _typOenv :: Environment _typOlib :: LocalIdentifierBindings _checkOenv :: Environment _typIannotatedTree :: TypeName _typInamedType :: Type _typIoriginalTree :: TypeName _checkIannotatedTree :: MaybeBoolExpression _checkIoriginalTree :: MaybeBoolExpression -- "./TypeChecking/Statements.ag"(line 61, column 9) _lhsOannotatedTree = {-# LINE 61 "./TypeChecking/Statements.ag" #-} annTypesAndErrors _backTree (tpeToT _tpe ) (getErrors _tpe ) $ Just (map StatementTypeA _statementType ++ [EnvUpdates _envUpdates ]) {-# LINE 10115 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 67, column 9) _lhsOenvUpdates = {-# LINE 67 "./TypeChecking/Statements.ag" #-} _envUpdates {-# LINE 10120 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 68, column 9) _lhsOlibUpdates = {-# LINE 68 "./TypeChecking/Statements.ag" #-} _libUpdates {-# LINE 10125 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 73, column 9) _libUpdates = {-# LINE 73 "./TypeChecking/Statements.ag" #-} [] {-# LINE 10130 "AstInternal.hs" #-} -- "./TypeChecking/MiscCreates.ag"(line 64, column 9) _tpe = {-# LINE 64 "./TypeChecking/MiscCreates.ag" #-} Right $ Pseudo Void {-# LINE 10135 "AstInternal.hs" #-} -- "./TypeChecking/MiscCreates.ag"(line 65, column 9) _backTree = {-# LINE 65 "./TypeChecking/MiscCreates.ag" #-} CreateDomain ann_ name_ _typIannotatedTree checkName_ _checkIannotatedTree {-# LINE 10140 "AstInternal.hs" #-} -- "./TypeChecking/MiscCreates.ag"(line 66, column 9) _statementType = {-# LINE 66 "./TypeChecking/MiscCreates.ag" #-} [] {-# LINE 10145 "AstInternal.hs" #-} -- "./TypeChecking/MiscCreates.ag"(line 67, column 9) _envUpdates = {-# LINE 67 "./TypeChecking/MiscCreates.ag" #-} [EnvCreateDomain (DomainType name_) _typInamedType] {-# LINE 10150 "AstInternal.hs" #-} -- "./TypeChecking/MiscCreates.ag"(line 69, column 9) _checkOlib = {-# LINE 69 "./TypeChecking/MiscCreates.ag" #-} fromRight _lhsIlib $ updateBindings _lhsIlib _lhsIenv [LibStackIDs [("", [("value", _typInamedType)])]] {-# LINE 10157 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} CreateDomain ann_ name_ _typIannotatedTree checkName_ _checkIannotatedTree {-# LINE 10162 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} CreateDomain ann_ name_ _typIoriginalTree checkName_ _checkIoriginalTree {-# LINE 10167 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 10172 "AstInternal.hs" #-} -- copy rule (down) _typOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 10177 "AstInternal.hs" #-} -- copy rule (down) _typOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 10182 "AstInternal.hs" #-} -- copy rule (down) _checkOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 10187 "AstInternal.hs" #-} ( _typIannotatedTree,_typInamedType,_typIoriginalTree) = (typ_ _typOenv _typOlib ) ( _checkIannotatedTree,_checkIoriginalTree) = (check_ _checkOenv _checkOlib ) in ( _lhsOannotatedTree,_lhsOenvUpdates,_lhsOlibUpdates,_lhsOoriginalTree))) sem_Statement_CreateFunction :: Annotation -> String -> T_ParamDefList -> T_TypeName -> T_Language -> String -> T_FnBody -> T_Volatility -> T_Statement sem_Statement_CreateFunction ann_ name_ params_ rettype_ lang_ bodyQuote_ body_ vol_ = (\ _lhsIenv _lhsIinProducedEnv _lhsIlib -> (let _lhsOannotatedTree :: Statement _lhsOenvUpdates :: ([EnvironmentUpdate]) _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _tpe :: (Either [TypeError] Type) _envUpdates :: ([EnvironmentUpdate]) _bodyOenv :: Environment _bodyOlib :: LocalIdentifierBindings _lhsOoriginalTree :: Statement _paramsOenv :: Environment _paramsOlib :: LocalIdentifierBindings _rettypeOenv :: Environment _rettypeOlib :: LocalIdentifierBindings _langOenv :: Environment _langOlib :: LocalIdentifierBindings _volOenv :: Environment _volOlib :: LocalIdentifierBindings _paramsIannotatedTree :: ParamDefList _paramsIoriginalTree :: ParamDefList _paramsIparams :: ([(String, Type)]) _rettypeIannotatedTree :: TypeName _rettypeInamedType :: Type _rettypeIoriginalTree :: TypeName _langIannotatedTree :: Language _langIoriginalTree :: Language _bodyIannotatedTree :: FnBody _bodyIoriginalTree :: FnBody _volIannotatedTree :: Volatility _volIoriginalTree :: Volatility -- "./TypeChecking/Statements.ag"(line 61, column 9) _lhsOannotatedTree = {-# LINE 61 "./TypeChecking/Statements.ag" #-} annTypesAndErrors _backTree (tpeToT _tpe ) (getErrors _tpe ) $ Just (map StatementTypeA _statementType ++ [EnvUpdates _envUpdates ]) {-# LINE 10242 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 67, column 9) _lhsOenvUpdates = {-# LINE 67 "./TypeChecking/Statements.ag" #-} _envUpdates {-# LINE 10247 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 68, column 9) _lhsOlibUpdates = {-# LINE 68 "./TypeChecking/Statements.ag" #-} _libUpdates {-# LINE 10252 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 73, column 9) _libUpdates = {-# LINE 73 "./TypeChecking/Statements.ag" #-} [] {-# LINE 10257 "AstInternal.hs" #-} -- "./TypeChecking/CreateFunction.ag"(line 23, column 9) _tpe = {-# LINE 23 "./TypeChecking/CreateFunction.ag" #-} dependsOnRTpe (_rettypeInamedType : _parameterTypes ) $ Right $ Pseudo Void {-# LINE 10264 "AstInternal.hs" #-} -- "./TypeChecking/CreateFunction.ag"(line 26, column 9) _envUpdates = {-# LINE 26 "./TypeChecking/CreateFunction.ag" #-} dependsOn [tpeToT _tpe ] [] [EnvCreateFunction FunName (map toLower name_) _parameterTypes _rettypeInamedType False] {-# LINE 10274 "AstInternal.hs" #-} -- "./TypeChecking/CreateFunction.ag"(line 32, column 9) _parameterTypes = {-# LINE 32 "./TypeChecking/CreateFunction.ag" #-} (map snd _paramsIparams) {-# LINE 10279 "AstInternal.hs" #-} -- "./TypeChecking/CreateFunction.ag"(line 34, column 9) _backTree = {-# LINE 34 "./TypeChecking/CreateFunction.ag" #-} CreateFunction ann_ name_ _paramsIannotatedTree _rettypeIannotatedTree _langIannotatedTree bodyQuote_ _bodyIannotatedTree _volIannotatedTree {-# LINE 10291 "AstInternal.hs" #-} -- "./TypeChecking/CreateFunction.ag"(line 42, column 9) _statementType = {-# LINE 42 "./TypeChecking/CreateFunction.ag" #-} [] {-# LINE 10296 "AstInternal.hs" #-} -- "./TypeChecking/CreateFunction.ag"(line 43, column 9) _bodyOenv = {-# LINE 43 "./TypeChecking/CreateFunction.ag" #-} _lhsIinProducedEnv {-# LINE 10301 "AstInternal.hs" #-} -- "./TypeChecking/CreateFunction.ag"(line 99, column 9) _bodyOlib = {-# LINE 99 "./TypeChecking/CreateFunction.ag" #-} let p = _paramsIparams ++ (zip posNames $ map snd _paramsIparams) in fromRight _lhsIlib $ updateBindings _lhsIlib _lhsIenv [LibStackIDs [("", p) ,(name_, _paramsIparams)]] where posNames :: [String] posNames = map (\l -> '$':show l) [1..] {-# LINE 10314 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} CreateFunction ann_ name_ _paramsIannotatedTree _rettypeIannotatedTree _langIannotatedTree bodyQuote_ _bodyIannotatedTree _volIannotatedTree {-# LINE 10319 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} CreateFunction ann_ name_ _paramsIoriginalTree _rettypeIoriginalTree _langIoriginalTree bodyQuote_ _bodyIoriginalTree _volIoriginalTree {-# LINE 10324 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 10329 "AstInternal.hs" #-} -- copy rule (down) _paramsOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 10334 "AstInternal.hs" #-} -- copy rule (down) _paramsOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 10339 "AstInternal.hs" #-} -- copy rule (down) _rettypeOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 10344 "AstInternal.hs" #-} -- copy rule (down) _rettypeOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 10349 "AstInternal.hs" #-} -- copy rule (down) _langOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 10354 "AstInternal.hs" #-} -- copy rule (down) _langOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 10359 "AstInternal.hs" #-} -- copy rule (down) _volOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 10364 "AstInternal.hs" #-} -- copy rule (down) _volOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 10369 "AstInternal.hs" #-} ( _paramsIannotatedTree,_paramsIoriginalTree,_paramsIparams) = (params_ _paramsOenv _paramsOlib ) ( _rettypeIannotatedTree,_rettypeInamedType,_rettypeIoriginalTree) = (rettype_ _rettypeOenv _rettypeOlib ) ( _langIannotatedTree,_langIoriginalTree) = (lang_ _langOenv _langOlib ) ( _bodyIannotatedTree,_bodyIoriginalTree) = (body_ _bodyOenv _bodyOlib ) ( _volIannotatedTree,_volIoriginalTree) = (vol_ _volOenv _volOlib ) in ( _lhsOannotatedTree,_lhsOenvUpdates,_lhsOlibUpdates,_lhsOoriginalTree))) sem_Statement_CreateLanguage :: Annotation -> String -> T_Statement sem_Statement_CreateLanguage ann_ name_ = (\ _lhsIenv _lhsIinProducedEnv _lhsIlib -> (let _lhsOenvUpdates :: ([EnvironmentUpdate]) _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _lhsOannotatedTree :: Statement _lhsOoriginalTree :: Statement -- "./TypeChecking/Statements.ag"(line 73, column 9) _libUpdates = {-# LINE 73 "./TypeChecking/Statements.ag" #-} [] {-# LINE 10396 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 89, column 9) _lhsOenvUpdates = {-# LINE 89 "./TypeChecking/Statements.ag" #-} [] {-# LINE 10401 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 90, column 9) _lhsOlibUpdates = {-# LINE 90 "./TypeChecking/Statements.ag" #-} [] {-# LINE 10406 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} CreateLanguage ann_ name_ {-# LINE 10411 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} CreateLanguage ann_ name_ {-# LINE 10416 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 10421 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 10426 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOenvUpdates,_lhsOlibUpdates,_lhsOoriginalTree))) sem_Statement_CreateSequence :: Annotation -> String -> Integer -> Integer -> Integer -> Integer -> Integer -> T_Statement sem_Statement_CreateSequence ann_ name_ incr_ min_ max_ start_ cache_ = (\ _lhsIenv _lhsIinProducedEnv _lhsIlib -> (let _lhsOenvUpdates :: ([EnvironmentUpdate]) _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _lhsOannotatedTree :: Statement _lhsOoriginalTree :: Statement -- "./TypeChecking/Statements.ag"(line 73, column 9) _libUpdates = {-# LINE 73 "./TypeChecking/Statements.ag" #-} [] {-# LINE 10448 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 89, column 9) _lhsOenvUpdates = {-# LINE 89 "./TypeChecking/Statements.ag" #-} [] {-# LINE 10453 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 90, column 9) _lhsOlibUpdates = {-# LINE 90 "./TypeChecking/Statements.ag" #-} [] {-# LINE 10458 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} CreateSequence ann_ name_ incr_ min_ max_ start_ cache_ {-# LINE 10463 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} CreateSequence ann_ name_ incr_ min_ max_ start_ cache_ {-# LINE 10468 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 10473 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 10478 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOenvUpdates,_lhsOlibUpdates,_lhsOoriginalTree))) sem_Statement_CreateTable :: Annotation -> String -> T_AttributeDefList -> T_ConstraintList -> T_Statement sem_Statement_CreateTable ann_ name_ atts_ cons_ = (\ _lhsIenv _lhsIinProducedEnv _lhsIlib -> (let _lhsOannotatedTree :: Statement _lhsOenvUpdates :: ([EnvironmentUpdate]) _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _tpe :: (Either [TypeError] Type) _envUpdates :: ([EnvironmentUpdate]) _attrTypes :: ([Type]) _consOlib :: LocalIdentifierBindings _lhsOoriginalTree :: Statement _attsOenv :: Environment _attsOlib :: LocalIdentifierBindings _consOenv :: Environment _attsIannotatedTree :: AttributeDefList _attsIattrs :: ([(String, Type)]) _attsIoriginalTree :: AttributeDefList _consIannotatedTree :: ConstraintList _consIoriginalTree :: ConstraintList -- "./TypeChecking/Statements.ag"(line 61, column 9) _lhsOannotatedTree = {-# LINE 61 "./TypeChecking/Statements.ag" #-} annTypesAndErrors _backTree (tpeToT _tpe ) (getErrors _tpe ) $ Just (map StatementTypeA _statementType ++ [EnvUpdates _envUpdates ]) {-# LINE 10513 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 67, column 9) _lhsOenvUpdates = {-# LINE 67 "./TypeChecking/Statements.ag" #-} _envUpdates {-# LINE 10518 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 68, column 9) _lhsOlibUpdates = {-# LINE 68 "./TypeChecking/Statements.ag" #-} _libUpdates {-# LINE 10523 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 73, column 9) _libUpdates = {-# LINE 73 "./TypeChecking/Statements.ag" #-} [] {-# LINE 10528 "AstInternal.hs" #-} -- "./TypeChecking/CreateTable.ag"(line 25, column 9) _tpe = {-# LINE 25 "./TypeChecking/CreateTable.ag" #-} dependsOnRTpe _attrTypes $ Right $ Pseudo Void {-# LINE 10533 "AstInternal.hs" #-} -- "./TypeChecking/CreateTable.ag"(line 26, column 9) _envUpdates = {-# LINE 26 "./TypeChecking/CreateTable.ag" #-} dependsOn _attrTypes [] [EnvCreateTable name_ _attsIattrs defaultSystemColumns] {-# LINE 10539 "AstInternal.hs" #-} -- "./TypeChecking/CreateTable.ag"(line 29, column 9) _attrTypes = {-# LINE 29 "./TypeChecking/CreateTable.ag" #-} map snd _attsIattrs {-# LINE 10544 "AstInternal.hs" #-} -- "./TypeChecking/CreateTable.ag"(line 31, column 9) _statementType = {-# LINE 31 "./TypeChecking/CreateTable.ag" #-} [] {-# LINE 10549 "AstInternal.hs" #-} -- "./TypeChecking/CreateTable.ag"(line 32, column 9) _backTree = {-# LINE 32 "./TypeChecking/CreateTable.ag" #-} CreateTable ann_ name_ _attsIannotatedTree _consIannotatedTree {-# LINE 10557 "AstInternal.hs" #-} -- "./TypeChecking/CreateTable.ag"(line 36, column 9) _consOlib = {-# LINE 36 "./TypeChecking/CreateTable.ag" #-} case updateBindings _lhsIlib _lhsIenv [LibStackIDs [("", _attsIattrs)]] of Left x -> error $ show x Right e -> e {-# LINE 10565 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} CreateTable ann_ name_ _attsIannotatedTree _consIannotatedTree {-# LINE 10570 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} CreateTable ann_ name_ _attsIoriginalTree _consIoriginalTree {-# LINE 10575 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 10580 "AstInternal.hs" #-} -- copy rule (down) _attsOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 10585 "AstInternal.hs" #-} -- copy rule (down) _attsOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 10590 "AstInternal.hs" #-} -- copy rule (down) _consOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 10595 "AstInternal.hs" #-} ( _attsIannotatedTree,_attsIattrs,_attsIoriginalTree) = (atts_ _attsOenv _attsOlib ) ( _consIannotatedTree,_consIoriginalTree) = (cons_ _consOenv _consOlib ) in ( _lhsOannotatedTree,_lhsOenvUpdates,_lhsOlibUpdates,_lhsOoriginalTree))) sem_Statement_CreateTableAs :: Annotation -> String -> T_SelectExpression -> T_Statement sem_Statement_CreateTableAs ann_ name_ expr_ = (\ _lhsIenv _lhsIinProducedEnv _lhsIlib -> (let _lhsOannotatedTree :: Statement _lhsOenvUpdates :: ([EnvironmentUpdate]) _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _tpe :: (Either [TypeError] Type) _envUpdates :: ([EnvironmentUpdate]) _lhsOoriginalTree :: Statement _exprOenv :: Environment _exprOlib :: LocalIdentifierBindings _exprIannotatedTree :: SelectExpression _exprIlibUpdates :: ([LocalIdentifierBindingsUpdate]) _exprIoriginalTree :: SelectExpression -- "./TypeChecking/Statements.ag"(line 61, column 9) _lhsOannotatedTree = {-# LINE 61 "./TypeChecking/Statements.ag" #-} annTypesAndErrors _backTree (tpeToT _tpe ) (getErrors _tpe ) $ Just (map StatementTypeA _statementType ++ [EnvUpdates _envUpdates ]) {-# LINE 10628 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 67, column 9) _lhsOenvUpdates = {-# LINE 67 "./TypeChecking/Statements.ag" #-} _envUpdates {-# LINE 10633 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 68, column 9) _lhsOlibUpdates = {-# LINE 68 "./TypeChecking/Statements.ag" #-} _libUpdates {-# LINE 10638 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 73, column 9) _libUpdates = {-# LINE 73 "./TypeChecking/Statements.ag" #-} [] {-# LINE 10643 "AstInternal.hs" #-} -- "./TypeChecking/CreateTable.ag"(line 53, column 9) _tpe = {-# LINE 53 "./TypeChecking/CreateTable.ag" #-} dependsOnRTpe [_selType ] $ do _attrs Right _selType {-# LINE 10650 "AstInternal.hs" #-} -- "./TypeChecking/CreateTable.ag"(line 57, column 9) _envUpdates = {-# LINE 57 "./TypeChecking/CreateTable.ag" #-} leftToEmpty (\as -> [EnvCreateTable name_ as defaultSystemColumns]) $ do ats <- _attrs return $ dependsOn (tpeToT _tpe : (map snd ats)) [] ats {-# LINE 10658 "AstInternal.hs" #-} -- "./TypeChecking/CreateTable.ag"(line 63, column 9) _selType = {-# LINE 63 "./TypeChecking/CreateTable.ag" #-} getTypeAnnotation _exprIannotatedTree {-# LINE 10663 "AstInternal.hs" #-} -- "./TypeChecking/CreateTable.ag"(line 65, column 9) _attrs = {-# LINE 65 "./TypeChecking/CreateTable.ag" #-} unwrapSetOfComposite _selType {-# LINE 10668 "AstInternal.hs" #-} -- "./TypeChecking/CreateTable.ag"(line 67, column 9) _backTree = {-# LINE 67 "./TypeChecking/CreateTable.ag" #-} CreateTableAs ann_ name_ _exprIannotatedTree {-# LINE 10673 "AstInternal.hs" #-} -- "./TypeChecking/CreateTable.ag"(line 68, column 9) _statementType = {-# LINE 68 "./TypeChecking/CreateTable.ag" #-} [] {-# LINE 10678 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} CreateTableAs ann_ name_ _exprIannotatedTree {-# LINE 10683 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} CreateTableAs ann_ name_ _exprIoriginalTree {-# LINE 10688 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 10693 "AstInternal.hs" #-} -- copy rule (down) _exprOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 10698 "AstInternal.hs" #-} -- copy rule (down) _exprOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 10703 "AstInternal.hs" #-} ( _exprIannotatedTree,_exprIlibUpdates,_exprIoriginalTree) = (expr_ _exprOenv _exprOlib ) in ( _lhsOannotatedTree,_lhsOenvUpdates,_lhsOlibUpdates,_lhsOoriginalTree))) sem_Statement_CreateTrigger :: Annotation -> String -> T_TriggerWhen -> ([TriggerEvent]) -> String -> T_TriggerFire -> String -> ([Expression]) -> T_Statement sem_Statement_CreateTrigger ann_ name_ wh_ events_ tbl_ firing_ fnName_ fnArgs_ = (\ _lhsIenv _lhsIinProducedEnv _lhsIlib -> (let _lhsOenvUpdates :: ([EnvironmentUpdate]) _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _lhsOannotatedTree :: Statement _lhsOoriginalTree :: Statement _whOenv :: Environment _whOlib :: LocalIdentifierBindings _firingOenv :: Environment _firingOlib :: LocalIdentifierBindings _whIannotatedTree :: TriggerWhen _whIoriginalTree :: TriggerWhen _firingIannotatedTree :: TriggerFire _firingIoriginalTree :: TriggerFire -- "./TypeChecking/Statements.ag"(line 89, column 9) _lhsOenvUpdates = {-# LINE 89 "./TypeChecking/Statements.ag" #-} [] {-# LINE 10736 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 90, column 9) _lhsOlibUpdates = {-# LINE 90 "./TypeChecking/Statements.ag" #-} [] {-# LINE 10741 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} CreateTrigger ann_ name_ _whIannotatedTree events_ tbl_ _firingIannotatedTree fnName_ fnArgs_ {-# LINE 10746 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} CreateTrigger ann_ name_ _whIoriginalTree events_ tbl_ _firingIoriginalTree fnName_ fnArgs_ {-# LINE 10751 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 10756 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 10761 "AstInternal.hs" #-} -- copy rule (down) _whOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 10766 "AstInternal.hs" #-} -- copy rule (down) _whOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 10771 "AstInternal.hs" #-} -- copy rule (down) _firingOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 10776 "AstInternal.hs" #-} -- copy rule (down) _firingOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 10781 "AstInternal.hs" #-} ( _whIannotatedTree,_whIoriginalTree) = (wh_ _whOenv _whOlib ) ( _firingIannotatedTree,_firingIoriginalTree) = (firing_ _firingOenv _firingOlib ) in ( _lhsOannotatedTree,_lhsOenvUpdates,_lhsOlibUpdates,_lhsOoriginalTree))) sem_Statement_CreateType :: Annotation -> String -> T_TypeAttributeDefList -> T_Statement sem_Statement_CreateType ann_ name_ atts_ = (\ _lhsIenv _lhsIinProducedEnv _lhsIlib -> (let _lhsOannotatedTree :: Statement _lhsOenvUpdates :: ([EnvironmentUpdate]) _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _tpe :: (Either [TypeError] Type) _envUpdates :: ([EnvironmentUpdate]) _lhsOoriginalTree :: Statement _attsOenv :: Environment _attsOlib :: LocalIdentifierBindings _attsIannotatedTree :: TypeAttributeDefList _attsIattrs :: ([(String, Type)]) _attsIoriginalTree :: TypeAttributeDefList -- "./TypeChecking/Statements.ag"(line 61, column 9) _lhsOannotatedTree = {-# LINE 61 "./TypeChecking/Statements.ag" #-} annTypesAndErrors _backTree (tpeToT _tpe ) (getErrors _tpe ) $ Just (map StatementTypeA _statementType ++ [EnvUpdates _envUpdates ]) {-# LINE 10814 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 67, column 9) _lhsOenvUpdates = {-# LINE 67 "./TypeChecking/Statements.ag" #-} _envUpdates {-# LINE 10819 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 68, column 9) _lhsOlibUpdates = {-# LINE 68 "./TypeChecking/Statements.ag" #-} _libUpdates {-# LINE 10824 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 73, column 9) _libUpdates = {-# LINE 73 "./TypeChecking/Statements.ag" #-} [] {-# LINE 10829 "AstInternal.hs" #-} -- "./TypeChecking/MiscCreates.ag"(line 51, column 9) _tpe = {-# LINE 51 "./TypeChecking/MiscCreates.ag" #-} Right $ Pseudo Void {-# LINE 10834 "AstInternal.hs" #-} -- "./TypeChecking/MiscCreates.ag"(line 52, column 9) _backTree = {-# LINE 52 "./TypeChecking/MiscCreates.ag" #-} CreateType ann_ name_ _attsIannotatedTree {-# LINE 10839 "AstInternal.hs" #-} -- "./TypeChecking/MiscCreates.ag"(line 53, column 9) _statementType = {-# LINE 53 "./TypeChecking/MiscCreates.ag" #-} [] {-# LINE 10844 "AstInternal.hs" #-} -- "./TypeChecking/MiscCreates.ag"(line 54, column 9) _envUpdates = {-# LINE 54 "./TypeChecking/MiscCreates.ag" #-} [EnvCreateComposite name_ _attsIattrs] {-# LINE 10849 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} CreateType ann_ name_ _attsIannotatedTree {-# LINE 10854 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} CreateType ann_ name_ _attsIoriginalTree {-# LINE 10859 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 10864 "AstInternal.hs" #-} -- copy rule (down) _attsOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 10869 "AstInternal.hs" #-} -- copy rule (down) _attsOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 10874 "AstInternal.hs" #-} ( _attsIannotatedTree,_attsIattrs,_attsIoriginalTree) = (atts_ _attsOenv _attsOlib ) in ( _lhsOannotatedTree,_lhsOenvUpdates,_lhsOlibUpdates,_lhsOoriginalTree))) sem_Statement_CreateView :: Annotation -> String -> T_SelectExpression -> T_Statement sem_Statement_CreateView ann_ name_ expr_ = (\ _lhsIenv _lhsIinProducedEnv _lhsIlib -> (let _lhsOannotatedTree :: Statement _lhsOenvUpdates :: ([EnvironmentUpdate]) _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _tpe :: (Either [TypeError] Type) _envUpdates :: ([EnvironmentUpdate]) _lhsOoriginalTree :: Statement _exprOenv :: Environment _exprOlib :: LocalIdentifierBindings _exprIannotatedTree :: SelectExpression _exprIlibUpdates :: ([LocalIdentifierBindingsUpdate]) _exprIoriginalTree :: SelectExpression -- "./TypeChecking/Statements.ag"(line 61, column 9) _lhsOannotatedTree = {-# LINE 61 "./TypeChecking/Statements.ag" #-} annTypesAndErrors _backTree (tpeToT _tpe ) (getErrors _tpe ) $ Just (map StatementTypeA _statementType ++ [EnvUpdates _envUpdates ]) {-# LINE 10905 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 67, column 9) _lhsOenvUpdates = {-# LINE 67 "./TypeChecking/Statements.ag" #-} _envUpdates {-# LINE 10910 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 68, column 9) _lhsOlibUpdates = {-# LINE 68 "./TypeChecking/Statements.ag" #-} _libUpdates {-# LINE 10915 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 73, column 9) _libUpdates = {-# LINE 73 "./TypeChecking/Statements.ag" #-} [] {-# LINE 10920 "AstInternal.hs" #-} -- "./TypeChecking/MiscCreates.ag"(line 15, column 9) _tpe = {-# LINE 15 "./TypeChecking/MiscCreates.ag" #-} dependsOnRTpe [getTypeAnnotation _exprIannotatedTree] $ Right $ Pseudo Void {-# LINE 10926 "AstInternal.hs" #-} -- "./TypeChecking/MiscCreates.ag"(line 17, column 9) _backTree = {-# LINE 17 "./TypeChecking/MiscCreates.ag" #-} CreateView ann_ name_ _exprIannotatedTree {-# LINE 10931 "AstInternal.hs" #-} -- "./TypeChecking/MiscCreates.ag"(line 18, column 9) _attrs = {-# LINE 18 "./TypeChecking/MiscCreates.ag" #-} case getTypeAnnotation _exprIannotatedTree of SetOfType (CompositeType c) -> c _ -> [] {-# LINE 10938 "AstInternal.hs" #-} -- "./TypeChecking/MiscCreates.ag"(line 21, column 9) _envUpdates = {-# LINE 21 "./TypeChecking/MiscCreates.ag" #-} [EnvCreateView name_ _attrs ] {-# LINE 10943 "AstInternal.hs" #-} -- "./TypeChecking/MiscCreates.ag"(line 22, column 9) _statementType = {-# LINE 22 "./TypeChecking/MiscCreates.ag" #-} [] {-# LINE 10948 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} CreateView ann_ name_ _exprIannotatedTree {-# LINE 10953 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} CreateView ann_ name_ _exprIoriginalTree {-# LINE 10958 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 10963 "AstInternal.hs" #-} -- copy rule (down) _exprOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 10968 "AstInternal.hs" #-} -- copy rule (down) _exprOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 10973 "AstInternal.hs" #-} ( _exprIannotatedTree,_exprIlibUpdates,_exprIoriginalTree) = (expr_ _exprOenv _exprOlib ) in ( _lhsOannotatedTree,_lhsOenvUpdates,_lhsOlibUpdates,_lhsOoriginalTree))) sem_Statement_Delete :: Annotation -> String -> T_MaybeBoolExpression -> T_MaybeSelectList -> T_Statement sem_Statement_Delete ann_ table_ whr_ returning_ = (\ _lhsIenv _lhsIinProducedEnv _lhsIlib -> (let _lhsOannotatedTree :: Statement _lhsOenvUpdates :: ([EnvironmentUpdate]) _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _tpe :: (Either [TypeError] Type) _envUpdates :: ([EnvironmentUpdate]) _whrOlib :: LocalIdentifierBindings _returningOlib :: LocalIdentifierBindings _lhsOoriginalTree :: Statement _whrOenv :: Environment _returningOenv :: Environment _whrIannotatedTree :: MaybeBoolExpression _whrIoriginalTree :: MaybeBoolExpression _returningIannotatedTree :: MaybeSelectList _returningIlistType :: (Maybe [(String,Type)]) _returningIoriginalTree :: MaybeSelectList -- "./TypeChecking/Statements.ag"(line 61, column 9) _lhsOannotatedTree = {-# LINE 61 "./TypeChecking/Statements.ag" #-} annTypesAndErrors _backTree (tpeToT _tpe ) (getErrors _tpe ) $ Just (map StatementTypeA _statementType ++ [EnvUpdates _envUpdates ]) {-# LINE 11009 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 67, column 9) _lhsOenvUpdates = {-# LINE 67 "./TypeChecking/Statements.ag" #-} _envUpdates {-# LINE 11014 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 68, column 9) _lhsOlibUpdates = {-# LINE 68 "./TypeChecking/Statements.ag" #-} _libUpdates {-# LINE 11019 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 73, column 9) _libUpdates = {-# LINE 73 "./TypeChecking/Statements.ag" #-} [] {-# LINE 11024 "AstInternal.hs" #-} -- "./TypeChecking/Dml.ag"(line 153, column 9) _tpe = {-# LINE 153 "./TypeChecking/Dml.ag" #-} checkRelationExists _lhsIenv table_ >> Right (Pseudo Void) {-# LINE 11030 "AstInternal.hs" #-} -- "./TypeChecking/Dml.ag"(line 156, column 9) _statementType = {-# LINE 156 "./TypeChecking/Dml.ag" #-} [StatementType [] (fromMaybe [] _returningIlistType)] {-# LINE 11035 "AstInternal.hs" #-} -- "./TypeChecking/Dml.ag"(line 158, column 9) _backTree = {-# LINE 158 "./TypeChecking/Dml.ag" #-} Delete ann_ table_ _whrIannotatedTree _returningIannotatedTree {-# LINE 11040 "AstInternal.hs" #-} -- "./TypeChecking/Dml.ag"(line 159, column 9) _envUpdates = {-# LINE 159 "./TypeChecking/Dml.ag" #-} [] {-# LINE 11045 "AstInternal.hs" #-} -- "./TypeChecking/Dml.ag"(line 164, column 9) _lib = {-# LINE 164 "./TypeChecking/Dml.ag" #-} fromRight _lhsIlib $ do columnTypes <- envCompositeAttrs _lhsIenv relationComposites table_ updateBindings _lhsIlib _lhsIenv [LibStackIDs [("", columnTypes)]] {-# LINE 11052 "AstInternal.hs" #-} -- "./TypeChecking/Dml.ag"(line 168, column 9) _whrOlib = {-# LINE 168 "./TypeChecking/Dml.ag" #-} _lib {-# LINE 11057 "AstInternal.hs" #-} -- "./TypeChecking/Dml.ag"(line 169, column 9) _returningOlib = {-# LINE 169 "./TypeChecking/Dml.ag" #-} _lib {-# LINE 11062 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Delete ann_ table_ _whrIannotatedTree _returningIannotatedTree {-# LINE 11067 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Delete ann_ table_ _whrIoriginalTree _returningIoriginalTree {-# LINE 11072 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 11077 "AstInternal.hs" #-} -- copy rule (down) _whrOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 11082 "AstInternal.hs" #-} -- copy rule (down) _returningOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 11087 "AstInternal.hs" #-} ( _whrIannotatedTree,_whrIoriginalTree) = (whr_ _whrOenv _whrOlib ) ( _returningIannotatedTree,_returningIlistType,_returningIoriginalTree) = (returning_ _returningOenv _returningOlib ) in ( _lhsOannotatedTree,_lhsOenvUpdates,_lhsOlibUpdates,_lhsOoriginalTree))) sem_Statement_DropFunction :: Annotation -> T_IfExists -> T_StringTypeNameListPairList -> T_Cascade -> T_Statement sem_Statement_DropFunction ann_ ifE_ sigs_ cascade_ = (\ _lhsIenv _lhsIinProducedEnv _lhsIlib -> (let _lhsOannotatedTree :: Statement _lhsOenvUpdates :: ([EnvironmentUpdate]) _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _tpe :: (Either [TypeError] Type) _envUpdates :: ([EnvironmentUpdate]) _lhsOoriginalTree :: Statement _ifEOenv :: Environment _ifEOlib :: LocalIdentifierBindings _sigsOenv :: Environment _sigsOlib :: LocalIdentifierBindings _cascadeOenv :: Environment _cascadeOlib :: LocalIdentifierBindings _ifEIannotatedTree :: IfExists _ifEIoriginalTree :: IfExists _sigsIannotatedTree :: StringTypeNameListPairList _sigsIfnSigs :: ([(String,[Type])]) _sigsIoriginalTree :: StringTypeNameListPairList _cascadeIannotatedTree :: Cascade _cascadeIoriginalTree :: Cascade -- "./TypeChecking/Statements.ag"(line 61, column 9) _lhsOannotatedTree = {-# LINE 61 "./TypeChecking/Statements.ag" #-} annTypesAndErrors _backTree (tpeToT _tpe ) (getErrors _tpe ) $ Just (map StatementTypeA _statementType ++ [EnvUpdates _envUpdates ]) {-# LINE 11129 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 67, column 9) _lhsOenvUpdates = {-# LINE 67 "./TypeChecking/Statements.ag" #-} _envUpdates {-# LINE 11134 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 68, column 9) _lhsOlibUpdates = {-# LINE 68 "./TypeChecking/Statements.ag" #-} _libUpdates {-# LINE 11139 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 73, column 9) _libUpdates = {-# LINE 73 "./TypeChecking/Statements.ag" #-} [] {-# LINE 11144 "AstInternal.hs" #-} -- "./TypeChecking/Drops.ag"(line 10, column 9) _tpe = {-# LINE 10 "./TypeChecking/Drops.ag" #-} Right $ Pseudo Void {-# LINE 11149 "AstInternal.hs" #-} -- "./TypeChecking/Drops.ag"(line 11, column 9) _backTree = {-# LINE 11 "./TypeChecking/Drops.ag" #-} DropFunction ann_ _ifEIannotatedTree _sigsIannotatedTree _cascadeIannotatedTree {-# LINE 11154 "AstInternal.hs" #-} -- "./TypeChecking/Drops.ag"(line 12, column 9) _envUpdates = {-# LINE 12 "./TypeChecking/Drops.ag" #-} flip map _sigsIfnSigs $ \(nm,args) -> EnvDropFunction ifE nm args where ifE = _ifEIannotatedTree == IfExists {-# LINE 11162 "AstInternal.hs" #-} -- "./TypeChecking/Drops.ag"(line 16, column 9) _statementType = {-# LINE 16 "./TypeChecking/Drops.ag" #-} [] {-# LINE 11167 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} DropFunction ann_ _ifEIannotatedTree _sigsIannotatedTree _cascadeIannotatedTree {-# LINE 11172 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} DropFunction ann_ _ifEIoriginalTree _sigsIoriginalTree _cascadeIoriginalTree {-# LINE 11177 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 11182 "AstInternal.hs" #-} -- copy rule (down) _ifEOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 11187 "AstInternal.hs" #-} -- copy rule (down) _ifEOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 11192 "AstInternal.hs" #-} -- copy rule (down) _sigsOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 11197 "AstInternal.hs" #-} -- copy rule (down) _sigsOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 11202 "AstInternal.hs" #-} -- copy rule (down) _cascadeOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 11207 "AstInternal.hs" #-} -- copy rule (down) _cascadeOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 11212 "AstInternal.hs" #-} ( _ifEIannotatedTree,_ifEIoriginalTree) = (ifE_ _ifEOenv _ifEOlib ) ( _sigsIannotatedTree,_sigsIfnSigs,_sigsIoriginalTree) = (sigs_ _sigsOenv _sigsOlib ) ( _cascadeIannotatedTree,_cascadeIoriginalTree) = (cascade_ _cascadeOenv _cascadeOlib ) in ( _lhsOannotatedTree,_lhsOenvUpdates,_lhsOlibUpdates,_lhsOoriginalTree))) sem_Statement_DropSomething :: Annotation -> T_DropType -> T_IfExists -> T_StringList -> T_Cascade -> T_Statement sem_Statement_DropSomething ann_ dropType_ ifE_ names_ cascade_ = (\ _lhsIenv _lhsIinProducedEnv _lhsIlib -> (let _lhsOenvUpdates :: ([EnvironmentUpdate]) _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _lhsOannotatedTree :: Statement _lhsOoriginalTree :: Statement _dropTypeOenv :: Environment _dropTypeOlib :: LocalIdentifierBindings _ifEOenv :: Environment _ifEOlib :: LocalIdentifierBindings _namesOenv :: Environment _namesOlib :: LocalIdentifierBindings _cascadeOenv :: Environment _cascadeOlib :: LocalIdentifierBindings _dropTypeIannotatedTree :: DropType _dropTypeIoriginalTree :: DropType _ifEIannotatedTree :: IfExists _ifEIoriginalTree :: IfExists _namesIannotatedTree :: StringList _namesIoriginalTree :: StringList _namesIstrings :: ([String]) _cascadeIannotatedTree :: Cascade _cascadeIoriginalTree :: Cascade -- "./TypeChecking/Statements.ag"(line 89, column 9) _lhsOenvUpdates = {-# LINE 89 "./TypeChecking/Statements.ag" #-} [] {-# LINE 11255 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 90, column 9) _lhsOlibUpdates = {-# LINE 90 "./TypeChecking/Statements.ag" #-} [] {-# LINE 11260 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} DropSomething ann_ _dropTypeIannotatedTree _ifEIannotatedTree _namesIannotatedTree _cascadeIannotatedTree {-# LINE 11265 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} DropSomething ann_ _dropTypeIoriginalTree _ifEIoriginalTree _namesIoriginalTree _cascadeIoriginalTree {-# LINE 11270 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 11275 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 11280 "AstInternal.hs" #-} -- copy rule (down) _dropTypeOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 11285 "AstInternal.hs" #-} -- copy rule (down) _dropTypeOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 11290 "AstInternal.hs" #-} -- copy rule (down) _ifEOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 11295 "AstInternal.hs" #-} -- copy rule (down) _ifEOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 11300 "AstInternal.hs" #-} -- copy rule (down) _namesOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 11305 "AstInternal.hs" #-} -- copy rule (down) _namesOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 11310 "AstInternal.hs" #-} -- copy rule (down) _cascadeOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 11315 "AstInternal.hs" #-} -- copy rule (down) _cascadeOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 11320 "AstInternal.hs" #-} ( _dropTypeIannotatedTree,_dropTypeIoriginalTree) = (dropType_ _dropTypeOenv _dropTypeOlib ) ( _ifEIannotatedTree,_ifEIoriginalTree) = (ifE_ _ifEOenv _ifEOlib ) ( _namesIannotatedTree,_namesIoriginalTree,_namesIstrings) = (names_ _namesOenv _namesOlib ) ( _cascadeIannotatedTree,_cascadeIoriginalTree) = (cascade_ _cascadeOenv _cascadeOlib ) in ( _lhsOannotatedTree,_lhsOenvUpdates,_lhsOlibUpdates,_lhsOoriginalTree))) sem_Statement_Execute :: Annotation -> T_Expression -> T_Statement sem_Statement_Execute ann_ expr_ = (\ _lhsIenv _lhsIinProducedEnv _lhsIlib -> (let _lhsOenvUpdates :: ([EnvironmentUpdate]) _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _lhsOannotatedTree :: Statement _lhsOoriginalTree :: Statement _exprOenv :: Environment _exprOlib :: LocalIdentifierBindings _exprIannotatedTree :: Expression _exprIliftedColumnName :: String _exprIoriginalTree :: Expression -- "./TypeChecking/Statements.ag"(line 89, column 9) _lhsOenvUpdates = {-# LINE 89 "./TypeChecking/Statements.ag" #-} [] {-# LINE 11350 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 90, column 9) _lhsOlibUpdates = {-# LINE 90 "./TypeChecking/Statements.ag" #-} [] {-# LINE 11355 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Execute ann_ _exprIannotatedTree {-# LINE 11360 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Execute ann_ _exprIoriginalTree {-# LINE 11365 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 11370 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 11375 "AstInternal.hs" #-} -- copy rule (down) _exprOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 11380 "AstInternal.hs" #-} -- copy rule (down) _exprOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 11385 "AstInternal.hs" #-} ( _exprIannotatedTree,_exprIliftedColumnName,_exprIoriginalTree) = (expr_ _exprOenv _exprOlib ) in ( _lhsOannotatedTree,_lhsOenvUpdates,_lhsOlibUpdates,_lhsOoriginalTree))) sem_Statement_ExecuteInto :: Annotation -> T_Expression -> T_StringList -> T_Statement sem_Statement_ExecuteInto ann_ expr_ targets_ = (\ _lhsIenv _lhsIinProducedEnv _lhsIlib -> (let _lhsOenvUpdates :: ([EnvironmentUpdate]) _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _lhsOannotatedTree :: Statement _lhsOoriginalTree :: Statement _exprOenv :: Environment _exprOlib :: LocalIdentifierBindings _targetsOenv :: Environment _targetsOlib :: LocalIdentifierBindings _exprIannotatedTree :: Expression _exprIliftedColumnName :: String _exprIoriginalTree :: Expression _targetsIannotatedTree :: StringList _targetsIoriginalTree :: StringList _targetsIstrings :: ([String]) -- "./TypeChecking/Statements.ag"(line 89, column 9) _lhsOenvUpdates = {-# LINE 89 "./TypeChecking/Statements.ag" #-} [] {-# LINE 11415 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 90, column 9) _lhsOlibUpdates = {-# LINE 90 "./TypeChecking/Statements.ag" #-} [] {-# LINE 11420 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} ExecuteInto ann_ _exprIannotatedTree _targetsIannotatedTree {-# LINE 11425 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} ExecuteInto ann_ _exprIoriginalTree _targetsIoriginalTree {-# LINE 11430 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 11435 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 11440 "AstInternal.hs" #-} -- copy rule (down) _exprOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 11445 "AstInternal.hs" #-} -- copy rule (down) _exprOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 11450 "AstInternal.hs" #-} -- copy rule (down) _targetsOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 11455 "AstInternal.hs" #-} -- copy rule (down) _targetsOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 11460 "AstInternal.hs" #-} ( _exprIannotatedTree,_exprIliftedColumnName,_exprIoriginalTree) = (expr_ _exprOenv _exprOlib ) ( _targetsIannotatedTree,_targetsIoriginalTree,_targetsIstrings) = (targets_ _targetsOenv _targetsOlib ) in ( _lhsOannotatedTree,_lhsOenvUpdates,_lhsOlibUpdates,_lhsOoriginalTree))) sem_Statement_ForIntegerStatement :: Annotation -> String -> T_Expression -> T_Expression -> T_StatementList -> T_Statement sem_Statement_ForIntegerStatement ann_ var_ from_ to_ sts_ = (\ _lhsIenv _lhsIinProducedEnv _lhsIlib -> (let _lhsOannotatedTree :: Statement _lhsOenvUpdates :: ([EnvironmentUpdate]) _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _stsOenvUpdates :: ([EnvironmentUpdate]) _stsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _tpe :: (Either [TypeError] Type) _stsOlib :: LocalIdentifierBindings _envUpdates :: ([EnvironmentUpdate]) _lhsOoriginalTree :: Statement _fromOenv :: Environment _fromOlib :: LocalIdentifierBindings _toOenv :: Environment _toOlib :: LocalIdentifierBindings _stsOenv :: Environment _fromIannotatedTree :: Expression _fromIliftedColumnName :: String _fromIoriginalTree :: Expression _toIannotatedTree :: Expression _toIliftedColumnName :: String _toIoriginalTree :: Expression _stsIannotatedTree :: StatementList _stsIoriginalTree :: StatementList _stsIproducedEnv :: Environment _stsIproducedLib :: LocalIdentifierBindings -- "./TypeChecking/Statements.ag"(line 61, column 9) _lhsOannotatedTree = {-# LINE 61 "./TypeChecking/Statements.ag" #-} annTypesAndErrors _backTree (tpeToT _tpe ) (getErrors _tpe ) $ Just (map StatementTypeA _statementType ++ [EnvUpdates _envUpdates ]) {-# LINE 11508 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 67, column 9) _lhsOenvUpdates = {-# LINE 67 "./TypeChecking/Statements.ag" #-} _envUpdates {-# LINE 11513 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 68, column 9) _lhsOlibUpdates = {-# LINE 68 "./TypeChecking/Statements.ag" #-} _libUpdates {-# LINE 11518 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 73, column 9) _libUpdates = {-# LINE 73 "./TypeChecking/Statements.ag" #-} [] {-# LINE 11523 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 110, column 9) _stsOenvUpdates = {-# LINE 110 "./TypeChecking/Statements.ag" #-} [] {-# LINE 11528 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 111, column 9) _stsOlibUpdates = {-# LINE 111 "./TypeChecking/Statements.ag" #-} [] {-# LINE 11533 "AstInternal.hs" #-} -- "./TypeChecking/Plpgsql.ag"(line 36, column 9) _varTypeE = {-# LINE 36 "./TypeChecking/Plpgsql.ag" #-} libLookupID _lhsIlib var_ {-# LINE 11538 "AstInternal.hs" #-} -- "./TypeChecking/Plpgsql.ag"(line 37, column 9) _tpe = {-# LINE 37 "./TypeChecking/Plpgsql.ag" #-} do let fromType = getTypeAnnotation _fromIannotatedTree toType = getTypeAnnotation _toIannotatedTree dependsOnRTpe [fromType,toType] $ do errorWhen (fromType /= toType) [FromToTypesNotSame fromType toType] case _varTypeE of Right t -> checkAssignmentValid _lhsIenv fromType t Left _ -> return () return $ Pseudo Void {-# LINE 11551 "AstInternal.hs" #-} -- "./TypeChecking/Plpgsql.ag"(line 48, column 9) _stsOlib = {-# LINE 48 "./TypeChecking/Plpgsql.ag" #-} case _varTypeE of Left [UnrecognisedIdentifier var_] -> fromRight _lhsIlib $ updateBindings _lhsIlib _lhsIenv [LibStackIDs [("", [(var_,getTypeAnnotation _fromIannotatedTree)])]] _ -> _lhsIlib {-# LINE 11561 "AstInternal.hs" #-} -- "./TypeChecking/Plpgsql.ag"(line 56, column 9) _backTree = {-# LINE 56 "./TypeChecking/Plpgsql.ag" #-} ForIntegerStatement ann_ var_ _fromIannotatedTree _toIannotatedTree _stsIannotatedTree {-# LINE 11566 "AstInternal.hs" #-} -- "./TypeChecking/Plpgsql.ag"(line 57, column 9) _envUpdates = {-# LINE 57 "./TypeChecking/Plpgsql.ag" #-} [] {-# LINE 11571 "AstInternal.hs" #-} -- "./TypeChecking/Plpgsql.ag"(line 58, column 9) _statementType = {-# LINE 58 "./TypeChecking/Plpgsql.ag" #-} [] {-# LINE 11576 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} ForIntegerStatement ann_ var_ _fromIannotatedTree _toIannotatedTree _stsIannotatedTree {-# LINE 11581 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} ForIntegerStatement ann_ var_ _fromIoriginalTree _toIoriginalTree _stsIoriginalTree {-# LINE 11586 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 11591 "AstInternal.hs" #-} -- copy rule (down) _fromOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 11596 "AstInternal.hs" #-} -- copy rule (down) _fromOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 11601 "AstInternal.hs" #-} -- copy rule (down) _toOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 11606 "AstInternal.hs" #-} -- copy rule (down) _toOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 11611 "AstInternal.hs" #-} -- copy rule (down) _stsOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 11616 "AstInternal.hs" #-} ( _fromIannotatedTree,_fromIliftedColumnName,_fromIoriginalTree) = (from_ _fromOenv _fromOlib ) ( _toIannotatedTree,_toIliftedColumnName,_toIoriginalTree) = (to_ _toOenv _toOlib ) ( _stsIannotatedTree,_stsIoriginalTree,_stsIproducedEnv,_stsIproducedLib) = (sts_ _stsOenv _stsOenvUpdates _stsOlib _stsOlibUpdates ) in ( _lhsOannotatedTree,_lhsOenvUpdates,_lhsOlibUpdates,_lhsOoriginalTree))) sem_Statement_ForSelectStatement :: Annotation -> String -> T_SelectExpression -> T_StatementList -> T_Statement sem_Statement_ForSelectStatement ann_ var_ sel_ sts_ = (\ _lhsIenv _lhsIinProducedEnv _lhsIlib -> (let _lhsOannotatedTree :: Statement _lhsOenvUpdates :: ([EnvironmentUpdate]) _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _stsOenvUpdates :: ([EnvironmentUpdate]) _stsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _tpe :: (Either [TypeError] Type) _stsOlib :: LocalIdentifierBindings _envUpdates :: ([EnvironmentUpdate]) _lhsOoriginalTree :: Statement _selOenv :: Environment _selOlib :: LocalIdentifierBindings _stsOenv :: Environment _selIannotatedTree :: SelectExpression _selIlibUpdates :: ([LocalIdentifierBindingsUpdate]) _selIoriginalTree :: SelectExpression _stsIannotatedTree :: StatementList _stsIoriginalTree :: StatementList _stsIproducedEnv :: Environment _stsIproducedLib :: LocalIdentifierBindings -- "./TypeChecking/Statements.ag"(line 61, column 9) _lhsOannotatedTree = {-# LINE 61 "./TypeChecking/Statements.ag" #-} annTypesAndErrors _backTree (tpeToT _tpe ) (getErrors _tpe ) $ Just (map StatementTypeA _statementType ++ [EnvUpdates _envUpdates ]) {-# LINE 11660 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 67, column 9) _lhsOenvUpdates = {-# LINE 67 "./TypeChecking/Statements.ag" #-} _envUpdates {-# LINE 11665 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 68, column 9) _lhsOlibUpdates = {-# LINE 68 "./TypeChecking/Statements.ag" #-} _libUpdates {-# LINE 11670 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 73, column 9) _libUpdates = {-# LINE 73 "./TypeChecking/Statements.ag" #-} [] {-# LINE 11675 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 110, column 9) _stsOenvUpdates = {-# LINE 110 "./TypeChecking/Statements.ag" #-} [] {-# LINE 11680 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 111, column 9) _stsOlibUpdates = {-# LINE 111 "./TypeChecking/Statements.ag" #-} [] {-# LINE 11685 "AstInternal.hs" #-} -- "./TypeChecking/Plpgsql.ag"(line 63, column 9) _selType = {-# LINE 63 "./TypeChecking/Plpgsql.ag" #-} getTypeAnnotation _selIannotatedTree {-# LINE 11690 "AstInternal.hs" #-} -- "./TypeChecking/Plpgsql.ag"(line 64, column 9) _tpe = {-# LINE 64 "./TypeChecking/Plpgsql.ag" #-} do dependsOnRTpe [_selType ] $ do toType <- libLookupID _lhsIlib var_ dependsOnRTpe [toType] $ do checkAssignmentValid _lhsIenv _selType toType return $ Pseudo Void {-# LINE 11700 "AstInternal.hs" #-} -- "./TypeChecking/Plpgsql.ag"(line 75, column 9) _stsOlib = {-# LINE 75 "./TypeChecking/Plpgsql.ag" #-} if okToUpdate then fromRight _lhsIlib $ updateBindings _lhsIlib _lhsIenv [LibStackIDs [("", [(var_,_selType )])]] else _lhsIlib where okToUpdate = isRight _tpe && _selType /= TypeCheckFailed {-# LINE 11710 "AstInternal.hs" #-} -- "./TypeChecking/Plpgsql.ag"(line 84, column 9) _backTree = {-# LINE 84 "./TypeChecking/Plpgsql.ag" #-} ForSelectStatement ann_ var_ _selIannotatedTree _stsIannotatedTree {-# LINE 11715 "AstInternal.hs" #-} -- "./TypeChecking/Plpgsql.ag"(line 85, column 9) _envUpdates = {-# LINE 85 "./TypeChecking/Plpgsql.ag" #-} [] {-# LINE 11720 "AstInternal.hs" #-} -- "./TypeChecking/Plpgsql.ag"(line 86, column 9) _statementType = {-# LINE 86 "./TypeChecking/Plpgsql.ag" #-} [] {-# LINE 11725 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} ForSelectStatement ann_ var_ _selIannotatedTree _stsIannotatedTree {-# LINE 11730 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} ForSelectStatement ann_ var_ _selIoriginalTree _stsIoriginalTree {-# LINE 11735 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 11740 "AstInternal.hs" #-} -- copy rule (down) _selOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 11745 "AstInternal.hs" #-} -- copy rule (down) _selOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 11750 "AstInternal.hs" #-} -- copy rule (down) _stsOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 11755 "AstInternal.hs" #-} ( _selIannotatedTree,_selIlibUpdates,_selIoriginalTree) = (sel_ _selOenv _selOlib ) ( _stsIannotatedTree,_stsIoriginalTree,_stsIproducedEnv,_stsIproducedLib) = (sts_ _stsOenv _stsOenvUpdates _stsOlib _stsOlibUpdates ) in ( _lhsOannotatedTree,_lhsOenvUpdates,_lhsOlibUpdates,_lhsOoriginalTree))) sem_Statement_If :: Annotation -> T_ExpressionStatementListPairList -> T_StatementList -> T_Statement sem_Statement_If ann_ cases_ els_ = (\ _lhsIenv _lhsIinProducedEnv _lhsIlib -> (let _lhsOenvUpdates :: ([EnvironmentUpdate]) _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _elsOenvUpdates :: ([EnvironmentUpdate]) _elsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _lhsOannotatedTree :: Statement _lhsOoriginalTree :: Statement _casesOenv :: Environment _casesOlib :: LocalIdentifierBindings _elsOenv :: Environment _elsOlib :: LocalIdentifierBindings _casesIannotatedTree :: ExpressionStatementListPairList _casesIoriginalTree :: ExpressionStatementListPairList _elsIannotatedTree :: StatementList _elsIoriginalTree :: StatementList _elsIproducedEnv :: Environment _elsIproducedLib :: LocalIdentifierBindings -- "./TypeChecking/Statements.ag"(line 89, column 9) _lhsOenvUpdates = {-# LINE 89 "./TypeChecking/Statements.ag" #-} [] {-# LINE 11789 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 90, column 9) _lhsOlibUpdates = {-# LINE 90 "./TypeChecking/Statements.ag" #-} [] {-# LINE 11794 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 106, column 9) _elsOenvUpdates = {-# LINE 106 "./TypeChecking/Statements.ag" #-} [] {-# LINE 11799 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 107, column 9) _elsOlibUpdates = {-# LINE 107 "./TypeChecking/Statements.ag" #-} [] {-# LINE 11804 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} If ann_ _casesIannotatedTree _elsIannotatedTree {-# LINE 11809 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} If ann_ _casesIoriginalTree _elsIoriginalTree {-# LINE 11814 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 11819 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 11824 "AstInternal.hs" #-} -- copy rule (down) _casesOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 11829 "AstInternal.hs" #-} -- copy rule (down) _casesOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 11834 "AstInternal.hs" #-} -- copy rule (down) _elsOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 11839 "AstInternal.hs" #-} -- copy rule (down) _elsOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 11844 "AstInternal.hs" #-} ( _casesIannotatedTree,_casesIoriginalTree) = (cases_ _casesOenv _casesOlib ) ( _elsIannotatedTree,_elsIoriginalTree,_elsIproducedEnv,_elsIproducedLib) = (els_ _elsOenv _elsOenvUpdates _elsOlib _elsOlibUpdates ) in ( _lhsOannotatedTree,_lhsOenvUpdates,_lhsOlibUpdates,_lhsOoriginalTree))) sem_Statement_Insert :: Annotation -> String -> T_StringList -> T_SelectExpression -> T_MaybeSelectList -> T_Statement sem_Statement_Insert ann_ table_ targetCols_ insData_ returning_ = (\ _lhsIenv _lhsIinProducedEnv _lhsIlib -> (let _lhsOannotatedTree :: Statement _lhsOenvUpdates :: ([EnvironmentUpdate]) _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _tpe :: (Either [TypeError] Type) _envUpdates :: ([EnvironmentUpdate]) _returningOlib :: LocalIdentifierBindings _lhsOoriginalTree :: Statement _targetColsOenv :: Environment _targetColsOlib :: LocalIdentifierBindings _insDataOenv :: Environment _insDataOlib :: LocalIdentifierBindings _returningOenv :: Environment _targetColsIannotatedTree :: StringList _targetColsIoriginalTree :: StringList _targetColsIstrings :: ([String]) _insDataIannotatedTree :: SelectExpression _insDataIlibUpdates :: ([LocalIdentifierBindingsUpdate]) _insDataIoriginalTree :: SelectExpression _returningIannotatedTree :: MaybeSelectList _returningIlistType :: (Maybe [(String,Type)]) _returningIoriginalTree :: MaybeSelectList -- "./TypeChecking/Statements.ag"(line 61, column 9) _lhsOannotatedTree = {-# LINE 61 "./TypeChecking/Statements.ag" #-} annTypesAndErrors _backTree (tpeToT _tpe ) (getErrors _tpe ) $ Just (map StatementTypeA _statementType ++ [EnvUpdates _envUpdates ]) {-# LINE 11889 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 67, column 9) _lhsOenvUpdates = {-# LINE 67 "./TypeChecking/Statements.ag" #-} _envUpdates {-# LINE 11894 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 68, column 9) _lhsOlibUpdates = {-# LINE 68 "./TypeChecking/Statements.ag" #-} _libUpdates {-# LINE 11899 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 73, column 9) _libUpdates = {-# LINE 73 "./TypeChecking/Statements.ag" #-} [] {-# LINE 11904 "AstInternal.hs" #-} -- "./TypeChecking/Dml.ag"(line 18, column 9) _tpe = {-# LINE 18 "./TypeChecking/Dml.ag" #-} dependsOnRTpe [getTypeAnnotation _insDataIannotatedTree] $ do _columnTypes Right $ Pseudo Void {-# LINE 11911 "AstInternal.hs" #-} -- "./TypeChecking/Dml.ag"(line 22, column 9) _statementType = {-# LINE 22 "./TypeChecking/Dml.ag" #-} leftToEmpty (\ct -> [StatementType [] (fromMaybe [] _returningIlistType)]) _columnTypes {-# LINE 11916 "AstInternal.hs" #-} -- "./TypeChecking/Dml.ag"(line 25, column 9) _columnTypes = {-# LINE 25 "./TypeChecking/Dml.ag" #-} do tys <- unwrapSetOfComposite $ getTypeAnnotation _insDataIannotatedTree checkColumnConsistency _lhsIenv table_ _targetColsIstrings tys {-# LINE 11927 "AstInternal.hs" #-} -- "./TypeChecking/Dml.ag"(line 34, column 9) _backTree = {-# LINE 34 "./TypeChecking/Dml.ag" #-} Insert ann_ table_ _targetColsIannotatedTree _insDataIannotatedTree _returningIannotatedTree {-# LINE 11933 "AstInternal.hs" #-} -- "./TypeChecking/Dml.ag"(line 36, column 9) _envUpdates = {-# LINE 36 "./TypeChecking/Dml.ag" #-} [] {-# LINE 11938 "AstInternal.hs" #-} -- "./TypeChecking/Dml.ag"(line 42, column 9) _returningOlib = {-# LINE 42 "./TypeChecking/Dml.ag" #-} fromRight _lhsIlib $ do atts <- envCompositeAttrs _lhsIenv relationComposites table_ updateBindings _lhsIlib _lhsIenv [LibStackIDs [("", atts)]] {-# LINE 11945 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Insert ann_ table_ _targetColsIannotatedTree _insDataIannotatedTree _returningIannotatedTree {-# LINE 11950 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Insert ann_ table_ _targetColsIoriginalTree _insDataIoriginalTree _returningIoriginalTree {-# LINE 11955 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 11960 "AstInternal.hs" #-} -- copy rule (down) _targetColsOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 11965 "AstInternal.hs" #-} -- copy rule (down) _targetColsOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 11970 "AstInternal.hs" #-} -- copy rule (down) _insDataOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 11975 "AstInternal.hs" #-} -- copy rule (down) _insDataOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 11980 "AstInternal.hs" #-} -- copy rule (down) _returningOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 11985 "AstInternal.hs" #-} ( _targetColsIannotatedTree,_targetColsIoriginalTree,_targetColsIstrings) = (targetCols_ _targetColsOenv _targetColsOlib ) ( _insDataIannotatedTree,_insDataIlibUpdates,_insDataIoriginalTree) = (insData_ _insDataOenv _insDataOlib ) ( _returningIannotatedTree,_returningIlistType,_returningIoriginalTree) = (returning_ _returningOenv _returningOlib ) in ( _lhsOannotatedTree,_lhsOenvUpdates,_lhsOlibUpdates,_lhsOoriginalTree))) sem_Statement_Notify :: Annotation -> String -> T_Statement sem_Statement_Notify ann_ name_ = (\ _lhsIenv _lhsIinProducedEnv _lhsIlib -> (let _lhsOenvUpdates :: ([EnvironmentUpdate]) _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _lhsOannotatedTree :: Statement _lhsOoriginalTree :: Statement -- "./TypeChecking/Statements.ag"(line 73, column 9) _libUpdates = {-# LINE 73 "./TypeChecking/Statements.ag" #-} [] {-# LINE 12008 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 89, column 9) _lhsOenvUpdates = {-# LINE 89 "./TypeChecking/Statements.ag" #-} [] {-# LINE 12013 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 90, column 9) _lhsOlibUpdates = {-# LINE 90 "./TypeChecking/Statements.ag" #-} [] {-# LINE 12018 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Notify ann_ name_ {-# LINE 12023 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Notify ann_ name_ {-# LINE 12028 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 12033 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 12038 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOenvUpdates,_lhsOlibUpdates,_lhsOoriginalTree))) sem_Statement_NullStatement :: Annotation -> T_Statement sem_Statement_NullStatement ann_ = (\ _lhsIenv _lhsIinProducedEnv _lhsIlib -> (let _lhsOenvUpdates :: ([EnvironmentUpdate]) _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _lhsOannotatedTree :: Statement _lhsOoriginalTree :: Statement -- "./TypeChecking/Statements.ag"(line 89, column 9) _lhsOenvUpdates = {-# LINE 89 "./TypeChecking/Statements.ag" #-} [] {-# LINE 12054 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 90, column 9) _lhsOlibUpdates = {-# LINE 90 "./TypeChecking/Statements.ag" #-} [] {-# LINE 12059 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} NullStatement ann_ {-# LINE 12064 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} NullStatement ann_ {-# LINE 12069 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 12074 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 12079 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOenvUpdates,_lhsOlibUpdates,_lhsOoriginalTree))) sem_Statement_Perform :: Annotation -> T_Expression -> T_Statement sem_Statement_Perform ann_ expr_ = (\ _lhsIenv _lhsIinProducedEnv _lhsIlib -> (let _lhsOenvUpdates :: ([EnvironmentUpdate]) _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _lhsOannotatedTree :: Statement _lhsOoriginalTree :: Statement _exprOenv :: Environment _exprOlib :: LocalIdentifierBindings _exprIannotatedTree :: Expression _exprIliftedColumnName :: String _exprIoriginalTree :: Expression -- "./TypeChecking/Statements.ag"(line 89, column 9) _lhsOenvUpdates = {-# LINE 89 "./TypeChecking/Statements.ag" #-} [] {-# LINE 12101 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 90, column 9) _lhsOlibUpdates = {-# LINE 90 "./TypeChecking/Statements.ag" #-} [] {-# LINE 12106 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Perform ann_ _exprIannotatedTree {-# LINE 12111 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Perform ann_ _exprIoriginalTree {-# LINE 12116 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 12121 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 12126 "AstInternal.hs" #-} -- copy rule (down) _exprOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 12131 "AstInternal.hs" #-} -- copy rule (down) _exprOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 12136 "AstInternal.hs" #-} ( _exprIannotatedTree,_exprIliftedColumnName,_exprIoriginalTree) = (expr_ _exprOenv _exprOlib ) in ( _lhsOannotatedTree,_lhsOenvUpdates,_lhsOlibUpdates,_lhsOoriginalTree))) sem_Statement_Raise :: Annotation -> T_RaiseType -> String -> T_ExpressionList -> T_Statement sem_Statement_Raise ann_ level_ message_ args_ = (\ _lhsIenv _lhsIinProducedEnv _lhsIlib -> (let _lhsOenvUpdates :: ([EnvironmentUpdate]) _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _lhsOannotatedTree :: Statement _lhsOoriginalTree :: Statement _levelOenv :: Environment _levelOlib :: LocalIdentifierBindings _argsOenv :: Environment _argsOlib :: LocalIdentifierBindings _levelIannotatedTree :: RaiseType _levelIoriginalTree :: RaiseType _argsIannotatedTree :: ExpressionList _argsIoriginalTree :: ExpressionList _argsItypeList :: ([Type]) -- "./TypeChecking/Statements.ag"(line 89, column 9) _lhsOenvUpdates = {-# LINE 89 "./TypeChecking/Statements.ag" #-} [] {-# LINE 12166 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 90, column 9) _lhsOlibUpdates = {-# LINE 90 "./TypeChecking/Statements.ag" #-} [] {-# LINE 12171 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Raise ann_ _levelIannotatedTree message_ _argsIannotatedTree {-# LINE 12176 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Raise ann_ _levelIoriginalTree message_ _argsIoriginalTree {-# LINE 12181 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 12186 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 12191 "AstInternal.hs" #-} -- copy rule (down) _levelOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 12196 "AstInternal.hs" #-} -- copy rule (down) _levelOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 12201 "AstInternal.hs" #-} -- copy rule (down) _argsOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 12206 "AstInternal.hs" #-} -- copy rule (down) _argsOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 12211 "AstInternal.hs" #-} ( _levelIannotatedTree,_levelIoriginalTree) = (level_ _levelOenv _levelOlib ) ( _argsIannotatedTree,_argsIoriginalTree,_argsItypeList) = (args_ _argsOenv _argsOlib ) in ( _lhsOannotatedTree,_lhsOenvUpdates,_lhsOlibUpdates,_lhsOoriginalTree))) sem_Statement_Return :: Annotation -> T_MaybeExpression -> T_Statement sem_Statement_Return ann_ value_ = (\ _lhsIenv _lhsIinProducedEnv _lhsIlib -> (let _lhsOannotatedTree :: Statement _lhsOenvUpdates :: ([EnvironmentUpdate]) _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _tpe :: (Either [TypeError] Type) _envUpdates :: ([EnvironmentUpdate]) _lhsOoriginalTree :: Statement _valueOenv :: Environment _valueOlib :: LocalIdentifierBindings _valueIannotatedTree :: MaybeExpression _valueIoriginalTree :: MaybeExpression -- "./TypeChecking/Statements.ag"(line 61, column 9) _lhsOannotatedTree = {-# LINE 61 "./TypeChecking/Statements.ag" #-} annTypesAndErrors _backTree (tpeToT _tpe ) (getErrors _tpe ) $ Just (map StatementTypeA _statementType ++ [EnvUpdates _envUpdates ]) {-# LINE 12242 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 67, column 9) _lhsOenvUpdates = {-# LINE 67 "./TypeChecking/Statements.ag" #-} _envUpdates {-# LINE 12247 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 68, column 9) _lhsOlibUpdates = {-# LINE 68 "./TypeChecking/Statements.ag" #-} _libUpdates {-# LINE 12252 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 73, column 9) _libUpdates = {-# LINE 73 "./TypeChecking/Statements.ag" #-} [] {-# LINE 12257 "AstInternal.hs" #-} -- "./TypeChecking/Plpgsql.ag"(line 12, column 9) _tpe = {-# LINE 12 "./TypeChecking/Plpgsql.ag" #-} dependsOnRTpe [maybe typeBool getTypeAnnotation _valueIannotatedTree] $ Right $ Pseudo Void {-# LINE 12264 "AstInternal.hs" #-} -- "./TypeChecking/Plpgsql.ag"(line 16, column 9) _backTree = {-# LINE 16 "./TypeChecking/Plpgsql.ag" #-} Return ann_ _valueIannotatedTree {-# LINE 12269 "AstInternal.hs" #-} -- "./TypeChecking/Plpgsql.ag"(line 17, column 9) _envUpdates = {-# LINE 17 "./TypeChecking/Plpgsql.ag" #-} [] {-# LINE 12274 "AstInternal.hs" #-} -- "./TypeChecking/Plpgsql.ag"(line 18, column 9) _statementType = {-# LINE 18 "./TypeChecking/Plpgsql.ag" #-} [] {-# LINE 12279 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Return ann_ _valueIannotatedTree {-# LINE 12284 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Return ann_ _valueIoriginalTree {-# LINE 12289 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 12294 "AstInternal.hs" #-} -- copy rule (down) _valueOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 12299 "AstInternal.hs" #-} -- copy rule (down) _valueOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 12304 "AstInternal.hs" #-} ( _valueIannotatedTree,_valueIoriginalTree) = (value_ _valueOenv _valueOlib ) in ( _lhsOannotatedTree,_lhsOenvUpdates,_lhsOlibUpdates,_lhsOoriginalTree))) sem_Statement_ReturnNext :: Annotation -> T_Expression -> T_Statement sem_Statement_ReturnNext ann_ expr_ = (\ _lhsIenv _lhsIinProducedEnv _lhsIlib -> (let _lhsOenvUpdates :: ([EnvironmentUpdate]) _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _lhsOannotatedTree :: Statement _lhsOoriginalTree :: Statement _exprOenv :: Environment _exprOlib :: LocalIdentifierBindings _exprIannotatedTree :: Expression _exprIliftedColumnName :: String _exprIoriginalTree :: Expression -- "./TypeChecking/Statements.ag"(line 89, column 9) _lhsOenvUpdates = {-# LINE 89 "./TypeChecking/Statements.ag" #-} [] {-# LINE 12328 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 90, column 9) _lhsOlibUpdates = {-# LINE 90 "./TypeChecking/Statements.ag" #-} [] {-# LINE 12333 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} ReturnNext ann_ _exprIannotatedTree {-# LINE 12338 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} ReturnNext ann_ _exprIoriginalTree {-# LINE 12343 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 12348 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 12353 "AstInternal.hs" #-} -- copy rule (down) _exprOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 12358 "AstInternal.hs" #-} -- copy rule (down) _exprOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 12363 "AstInternal.hs" #-} ( _exprIannotatedTree,_exprIliftedColumnName,_exprIoriginalTree) = (expr_ _exprOenv _exprOlib ) in ( _lhsOannotatedTree,_lhsOenvUpdates,_lhsOlibUpdates,_lhsOoriginalTree))) sem_Statement_ReturnQuery :: Annotation -> T_SelectExpression -> T_Statement sem_Statement_ReturnQuery ann_ sel_ = (\ _lhsIenv _lhsIinProducedEnv _lhsIlib -> (let _lhsOenvUpdates :: ([EnvironmentUpdate]) _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _lhsOannotatedTree :: Statement _lhsOoriginalTree :: Statement _selOenv :: Environment _selOlib :: LocalIdentifierBindings _selIannotatedTree :: SelectExpression _selIlibUpdates :: ([LocalIdentifierBindingsUpdate]) _selIoriginalTree :: SelectExpression -- "./TypeChecking/Statements.ag"(line 89, column 9) _lhsOenvUpdates = {-# LINE 89 "./TypeChecking/Statements.ag" #-} [] {-# LINE 12387 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 90, column 9) _lhsOlibUpdates = {-# LINE 90 "./TypeChecking/Statements.ag" #-} [] {-# LINE 12392 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} ReturnQuery ann_ _selIannotatedTree {-# LINE 12397 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} ReturnQuery ann_ _selIoriginalTree {-# LINE 12402 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 12407 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 12412 "AstInternal.hs" #-} -- copy rule (down) _selOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 12417 "AstInternal.hs" #-} -- copy rule (down) _selOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 12422 "AstInternal.hs" #-} ( _selIannotatedTree,_selIlibUpdates,_selIoriginalTree) = (sel_ _selOenv _selOlib ) in ( _lhsOannotatedTree,_lhsOenvUpdates,_lhsOlibUpdates,_lhsOoriginalTree))) sem_Statement_SelectStatement :: Annotation -> T_SelectExpression -> T_Statement sem_Statement_SelectStatement ann_ ex_ = (\ _lhsIenv _lhsIinProducedEnv _lhsIlib -> (let _lhsOannotatedTree :: Statement _lhsOenvUpdates :: ([EnvironmentUpdate]) _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _tpe :: (Either [TypeError] Type) _envUpdates :: ([EnvironmentUpdate]) _lhsOoriginalTree :: Statement _exOenv :: Environment _exOlib :: LocalIdentifierBindings _exIannotatedTree :: SelectExpression _exIlibUpdates :: ([LocalIdentifierBindingsUpdate]) _exIoriginalTree :: SelectExpression -- "./TypeChecking/Statements.ag"(line 61, column 9) _lhsOannotatedTree = {-# LINE 61 "./TypeChecking/Statements.ag" #-} annTypesAndErrors _backTree (tpeToT _tpe ) (getErrors _tpe ) $ Just (map StatementTypeA _statementType ++ [EnvUpdates _envUpdates ]) {-# LINE 12452 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 67, column 9) _lhsOenvUpdates = {-# LINE 67 "./TypeChecking/Statements.ag" #-} _envUpdates {-# LINE 12457 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 68, column 9) _lhsOlibUpdates = {-# LINE 68 "./TypeChecking/Statements.ag" #-} _libUpdates {-# LINE 12462 "AstInternal.hs" #-} -- "./TypeChecking/SelectStatement.ag"(line 14, column 9) _tpe = {-# LINE 14 "./TypeChecking/SelectStatement.ag" #-} dependsOnRTpe [getTypeAnnotation _exIannotatedTree] $ Right $ Pseudo Void {-# LINE 12467 "AstInternal.hs" #-} -- "./TypeChecking/SelectStatement.ag"(line 15, column 9) _statementType = {-# LINE 15 "./TypeChecking/SelectStatement.ag" #-} [StatementType ph $ leftToEmpty id $ unwrapSetOfComposite $ getTypeAnnotation _exIannotatedTree] where ph = flip map (getPlaceholders _exIannotatedTree) $ const $ ScalarType "text" {-# LINE 12477 "AstInternal.hs" #-} -- "./TypeChecking/SelectStatement.ag"(line 21, column 9) _backTree = {-# LINE 21 "./TypeChecking/SelectStatement.ag" #-} SelectStatement ann_ _exIannotatedTree {-# LINE 12482 "AstInternal.hs" #-} -- "./TypeChecking/SelectStatement.ag"(line 22, column 9) _envUpdates = {-# LINE 22 "./TypeChecking/SelectStatement.ag" #-} [] {-# LINE 12487 "AstInternal.hs" #-} -- "./TypeChecking/SelectLists.ag"(line 79, column 9) _libUpdates = {-# LINE 79 "./TypeChecking/SelectLists.ag" #-} _exIlibUpdates {-# LINE 12492 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} SelectStatement ann_ _exIannotatedTree {-# LINE 12497 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} SelectStatement ann_ _exIoriginalTree {-# LINE 12502 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 12507 "AstInternal.hs" #-} -- copy rule (down) _exOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 12512 "AstInternal.hs" #-} -- copy rule (down) _exOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 12517 "AstInternal.hs" #-} ( _exIannotatedTree,_exIlibUpdates,_exIoriginalTree) = (ex_ _exOenv _exOlib ) in ( _lhsOannotatedTree,_lhsOenvUpdates,_lhsOlibUpdates,_lhsOoriginalTree))) sem_Statement_Set :: Annotation -> String -> ([SetValue]) -> T_Statement sem_Statement_Set ann_ name_ values_ = (\ _lhsIenv _lhsIinProducedEnv _lhsIlib -> (let _lhsOenvUpdates :: ([EnvironmentUpdate]) _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _lhsOannotatedTree :: Statement _lhsOoriginalTree :: Statement -- "./TypeChecking/Statements.ag"(line 73, column 9) _libUpdates = {-# LINE 73 "./TypeChecking/Statements.ag" #-} [] {-# LINE 12537 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 89, column 9) _lhsOenvUpdates = {-# LINE 89 "./TypeChecking/Statements.ag" #-} [] {-# LINE 12542 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 90, column 9) _lhsOlibUpdates = {-# LINE 90 "./TypeChecking/Statements.ag" #-} [] {-# LINE 12547 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Set ann_ name_ values_ {-# LINE 12552 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Set ann_ name_ values_ {-# LINE 12557 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 12562 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 12567 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOenvUpdates,_lhsOlibUpdates,_lhsOoriginalTree))) sem_Statement_Truncate :: Annotation -> T_StringList -> T_RestartIdentity -> T_Cascade -> T_Statement sem_Statement_Truncate ann_ tables_ restartIdentity_ cascade_ = (\ _lhsIenv _lhsIinProducedEnv _lhsIlib -> (let _lhsOenvUpdates :: ([EnvironmentUpdate]) _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _lhsOannotatedTree :: Statement _lhsOoriginalTree :: Statement _tablesOenv :: Environment _tablesOlib :: LocalIdentifierBindings _restartIdentityOenv :: Environment _restartIdentityOlib :: LocalIdentifierBindings _cascadeOenv :: Environment _cascadeOlib :: LocalIdentifierBindings _tablesIannotatedTree :: StringList _tablesIoriginalTree :: StringList _tablesIstrings :: ([String]) _restartIdentityIannotatedTree :: RestartIdentity _restartIdentityIoriginalTree :: RestartIdentity _cascadeIannotatedTree :: Cascade _cascadeIoriginalTree :: Cascade -- "./TypeChecking/Statements.ag"(line 89, column 9) _lhsOenvUpdates = {-# LINE 89 "./TypeChecking/Statements.ag" #-} [] {-# LINE 12599 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 90, column 9) _lhsOlibUpdates = {-# LINE 90 "./TypeChecking/Statements.ag" #-} [] {-# LINE 12604 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Truncate ann_ _tablesIannotatedTree _restartIdentityIannotatedTree _cascadeIannotatedTree {-# LINE 12609 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Truncate ann_ _tablesIoriginalTree _restartIdentityIoriginalTree _cascadeIoriginalTree {-# LINE 12614 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 12619 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 12624 "AstInternal.hs" #-} -- copy rule (down) _tablesOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 12629 "AstInternal.hs" #-} -- copy rule (down) _tablesOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 12634 "AstInternal.hs" #-} -- copy rule (down) _restartIdentityOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 12639 "AstInternal.hs" #-} -- copy rule (down) _restartIdentityOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 12644 "AstInternal.hs" #-} -- copy rule (down) _cascadeOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 12649 "AstInternal.hs" #-} -- copy rule (down) _cascadeOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 12654 "AstInternal.hs" #-} ( _tablesIannotatedTree,_tablesIoriginalTree,_tablesIstrings) = (tables_ _tablesOenv _tablesOlib ) ( _restartIdentityIannotatedTree,_restartIdentityIoriginalTree) = (restartIdentity_ _restartIdentityOenv _restartIdentityOlib ) ( _cascadeIannotatedTree,_cascadeIoriginalTree) = (cascade_ _cascadeOenv _cascadeOlib ) in ( _lhsOannotatedTree,_lhsOenvUpdates,_lhsOlibUpdates,_lhsOoriginalTree))) sem_Statement_Update :: Annotation -> String -> T_SetClauseList -> T_MaybeBoolExpression -> T_MaybeSelectList -> T_Statement sem_Statement_Update ann_ table_ assigns_ whr_ returning_ = (\ _lhsIenv _lhsIinProducedEnv _lhsIlib -> (let _lhsOannotatedTree :: Statement _lhsOenvUpdates :: ([EnvironmentUpdate]) _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _tpe :: (Either [TypeError] Type) _envUpdates :: ([EnvironmentUpdate]) _whrOlib :: LocalIdentifierBindings _assignsOlib :: LocalIdentifierBindings _returningOlib :: LocalIdentifierBindings _lhsOoriginalTree :: Statement _assignsOenv :: Environment _whrOenv :: Environment _returningOenv :: Environment _assignsIannotatedTree :: SetClauseList _assignsIoriginalTree :: SetClauseList _assignsIpairs :: ([(String,Type)]) _assignsIrowSetErrors :: ([TypeError]) _whrIannotatedTree :: MaybeBoolExpression _whrIoriginalTree :: MaybeBoolExpression _returningIannotatedTree :: MaybeSelectList _returningIlistType :: (Maybe [(String,Type)]) _returningIoriginalTree :: MaybeSelectList -- "./TypeChecking/Statements.ag"(line 61, column 9) _lhsOannotatedTree = {-# LINE 61 "./TypeChecking/Statements.ag" #-} annTypesAndErrors _backTree (tpeToT _tpe ) (getErrors _tpe ) $ Just (map StatementTypeA _statementType ++ [EnvUpdates _envUpdates ]) {-# LINE 12701 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 67, column 9) _lhsOenvUpdates = {-# LINE 67 "./TypeChecking/Statements.ag" #-} _envUpdates {-# LINE 12706 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 68, column 9) _lhsOlibUpdates = {-# LINE 68 "./TypeChecking/Statements.ag" #-} _libUpdates {-# LINE 12711 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 73, column 9) _libUpdates = {-# LINE 73 "./TypeChecking/Statements.ag" #-} [] {-# LINE 12716 "AstInternal.hs" #-} -- "./TypeChecking/Dml.ag"(line 58, column 9) _tpe = {-# LINE 58 "./TypeChecking/Dml.ag" #-} do checkRelationExists _lhsIenv table_ dependsOnRTpe (map snd _assignsIpairs) $ do _columnTypes liftErrors _assignsIrowSetErrors return $ Pseudo Void {-# LINE 12726 "AstInternal.hs" #-} -- "./TypeChecking/Dml.ag"(line 65, column 9) _statementType = {-# LINE 65 "./TypeChecking/Dml.ag" #-} leftToEmpty (\ct -> [StatementType [] (fromMaybe [] _returningIlistType)]) _columnTypes {-# LINE 12731 "AstInternal.hs" #-} -- "./TypeChecking/Dml.ag"(line 68, column 9) _columnTypes = {-# LINE 68 "./TypeChecking/Dml.ag" #-} checkColumnConsistency _lhsIenv table_ (map fst _assignsIpairs) _assignsIpairs {-# LINE 12739 "AstInternal.hs" #-} -- "./TypeChecking/Dml.ag"(line 74, column 9) _backTree = {-# LINE 74 "./TypeChecking/Dml.ag" #-} Update ann_ table_ _assignsIannotatedTree _whrIannotatedTree _returningIannotatedTree {-# LINE 12748 "AstInternal.hs" #-} -- "./TypeChecking/Dml.ag"(line 79, column 9) _envUpdates = {-# LINE 79 "./TypeChecking/Dml.ag" #-} [] {-# LINE 12753 "AstInternal.hs" #-} -- "./TypeChecking/Dml.ag"(line 87, column 9) _lib = {-# LINE 87 "./TypeChecking/Dml.ag" #-} fromRight _lhsIlib $ do ct <- envCompositeAttrs _lhsIenv relationComposites table_ updateBindings _lhsIlib _lhsIenv [LibStackIDs [("", ct)]] {-# LINE 12762 "AstInternal.hs" #-} -- "./TypeChecking/Dml.ag"(line 93, column 9) _whrOlib = {-# LINE 93 "./TypeChecking/Dml.ag" #-} _lib {-# LINE 12767 "AstInternal.hs" #-} -- "./TypeChecking/Dml.ag"(line 94, column 9) _assignsOlib = {-# LINE 94 "./TypeChecking/Dml.ag" #-} _lib {-# LINE 12772 "AstInternal.hs" #-} -- "./TypeChecking/Dml.ag"(line 95, column 9) _returningOlib = {-# LINE 95 "./TypeChecking/Dml.ag" #-} _lib {-# LINE 12777 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Update ann_ table_ _assignsIannotatedTree _whrIannotatedTree _returningIannotatedTree {-# LINE 12782 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Update ann_ table_ _assignsIoriginalTree _whrIoriginalTree _returningIoriginalTree {-# LINE 12787 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 12792 "AstInternal.hs" #-} -- copy rule (down) _assignsOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 12797 "AstInternal.hs" #-} -- copy rule (down) _whrOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 12802 "AstInternal.hs" #-} -- copy rule (down) _returningOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 12807 "AstInternal.hs" #-} ( _assignsIannotatedTree,_assignsIoriginalTree,_assignsIpairs,_assignsIrowSetErrors) = (assigns_ _assignsOenv _assignsOlib ) ( _whrIannotatedTree,_whrIoriginalTree) = (whr_ _whrOenv _whrOlib ) ( _returningIannotatedTree,_returningIlistType,_returningIoriginalTree) = (returning_ _returningOenv _returningOlib ) in ( _lhsOannotatedTree,_lhsOenvUpdates,_lhsOlibUpdates,_lhsOoriginalTree))) sem_Statement_WhileStatement :: Annotation -> T_Expression -> T_StatementList -> T_Statement sem_Statement_WhileStatement ann_ expr_ sts_ = (\ _lhsIenv _lhsIinProducedEnv _lhsIlib -> (let _lhsOenvUpdates :: ([EnvironmentUpdate]) _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _stsOenvUpdates :: ([EnvironmentUpdate]) _stsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _lhsOannotatedTree :: Statement _lhsOoriginalTree :: Statement _exprOenv :: Environment _exprOlib :: LocalIdentifierBindings _stsOenv :: Environment _stsOlib :: LocalIdentifierBindings _exprIannotatedTree :: Expression _exprIliftedColumnName :: String _exprIoriginalTree :: Expression _stsIannotatedTree :: StatementList _stsIoriginalTree :: StatementList _stsIproducedEnv :: Environment _stsIproducedLib :: LocalIdentifierBindings -- "./TypeChecking/Statements.ag"(line 89, column 9) _lhsOenvUpdates = {-# LINE 89 "./TypeChecking/Statements.ag" #-} [] {-# LINE 12844 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 90, column 9) _lhsOlibUpdates = {-# LINE 90 "./TypeChecking/Statements.ag" #-} [] {-# LINE 12849 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 110, column 9) _stsOenvUpdates = {-# LINE 110 "./TypeChecking/Statements.ag" #-} [] {-# LINE 12854 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 111, column 9) _stsOlibUpdates = {-# LINE 111 "./TypeChecking/Statements.ag" #-} [] {-# LINE 12859 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} WhileStatement ann_ _exprIannotatedTree _stsIannotatedTree {-# LINE 12864 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} WhileStatement ann_ _exprIoriginalTree _stsIoriginalTree {-# LINE 12869 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 12874 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 12879 "AstInternal.hs" #-} -- copy rule (down) _exprOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 12884 "AstInternal.hs" #-} -- copy rule (down) _exprOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 12889 "AstInternal.hs" #-} -- copy rule (down) _stsOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 12894 "AstInternal.hs" #-} -- copy rule (down) _stsOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 12899 "AstInternal.hs" #-} ( _exprIannotatedTree,_exprIliftedColumnName,_exprIoriginalTree) = (expr_ _exprOenv _exprOlib ) ( _stsIannotatedTree,_stsIoriginalTree,_stsIproducedEnv,_stsIproducedLib) = (sts_ _stsOenv _stsOenvUpdates _stsOlib _stsOlibUpdates ) in ( _lhsOannotatedTree,_lhsOenvUpdates,_lhsOlibUpdates,_lhsOoriginalTree))) -- StatementList ----------------------------------------------- {- visit 0: inherited attributes: env : Environment envUpdates : [EnvironmentUpdate] lib : LocalIdentifierBindings libUpdates : [LocalIdentifierBindingsUpdate] synthesized attributes: annotatedTree : SELF originalTree : SELF producedEnv : Environment producedLib : LocalIdentifierBindings alternatives: alternative Cons: child hd : Statement child tl : StatementList visit 0: local newEnv : _ local newLib : _ local annotatedTree : _ local originalTree : _ alternative Nil: visit 0: local newEnv : _ local newLib : _ local annotatedTree : _ local originalTree : _ -} type StatementList = [(Statement)] -- cata sem_StatementList :: StatementList -> T_StatementList sem_StatementList list = (Prelude.foldr sem_StatementList_Cons sem_StatementList_Nil (Prelude.map sem_Statement list) ) -- semantic domain type T_StatementList = Environment -> ([EnvironmentUpdate]) -> LocalIdentifierBindings -> ([LocalIdentifierBindingsUpdate]) -> ( StatementList,StatementList,Environment,LocalIdentifierBindings) data Inh_StatementList = Inh_StatementList {env_Inh_StatementList :: Environment,envUpdates_Inh_StatementList :: [EnvironmentUpdate],lib_Inh_StatementList :: LocalIdentifierBindings,libUpdates_Inh_StatementList :: [LocalIdentifierBindingsUpdate]} data Syn_StatementList = Syn_StatementList {annotatedTree_Syn_StatementList :: StatementList,originalTree_Syn_StatementList :: StatementList,producedEnv_Syn_StatementList :: Environment,producedLib_Syn_StatementList :: LocalIdentifierBindings} wrap_StatementList :: T_StatementList -> Inh_StatementList -> Syn_StatementList wrap_StatementList sem (Inh_StatementList _lhsIenv _lhsIenvUpdates _lhsIlib _lhsIlibUpdates ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree,_lhsOproducedEnv,_lhsOproducedLib) = (sem _lhsIenv _lhsIenvUpdates _lhsIlib _lhsIlibUpdates ) in (Syn_StatementList _lhsOannotatedTree _lhsOoriginalTree _lhsOproducedEnv _lhsOproducedLib )) sem_StatementList_Cons :: T_Statement -> T_StatementList -> T_StatementList sem_StatementList_Cons hd_ tl_ = (\ _lhsIenv _lhsIenvUpdates _lhsIlib _lhsIlibUpdates -> (let _hdOenv :: Environment _tlOenv :: Environment _hdOlib :: LocalIdentifierBindings _tlOlib :: LocalIdentifierBindings _lhsOproducedEnv :: Environment _lhsOproducedLib :: LocalIdentifierBindings _tlOenvUpdates :: ([EnvironmentUpdate]) _tlOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _hdOinProducedEnv :: Environment _lhsOannotatedTree :: StatementList _lhsOoriginalTree :: StatementList _hdIannotatedTree :: Statement _hdIenvUpdates :: ([EnvironmentUpdate]) _hdIlibUpdates :: ([LocalIdentifierBindingsUpdate]) _hdIoriginalTree :: Statement _tlIannotatedTree :: StatementList _tlIoriginalTree :: StatementList _tlIproducedEnv :: Environment _tlIproducedLib :: LocalIdentifierBindings -- "./TypeChecking/Statements.ag"(line 36, column 9) _newEnv = {-# LINE 36 "./TypeChecking/Statements.ag" #-} fromRight _lhsIenv $ updateEnvironment _lhsIenv _lhsIenvUpdates {-# LINE 12986 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 37, column 9) _newLib = {-# LINE 37 "./TypeChecking/Statements.ag" #-} fromRight _lhsIlib $ updateBindings _lhsIlib _lhsIenv _lhsIlibUpdates {-# LINE 12991 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 39, column 9) _hdOenv = {-# LINE 39 "./TypeChecking/Statements.ag" #-} _newEnv {-# LINE 12996 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 40, column 9) _tlOenv = {-# LINE 40 "./TypeChecking/Statements.ag" #-} _newEnv {-# LINE 13001 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 41, column 9) _hdOlib = {-# LINE 41 "./TypeChecking/Statements.ag" #-} _newLib {-# LINE 13006 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 42, column 9) _tlOlib = {-# LINE 42 "./TypeChecking/Statements.ag" #-} _newLib {-# LINE 13011 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 46, column 9) _lhsOproducedEnv = {-# LINE 46 "./TypeChecking/Statements.ag" #-} _tlIproducedEnv {-# LINE 13016 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 47, column 9) _lhsOproducedLib = {-# LINE 47 "./TypeChecking/Statements.ag" #-} _tlIproducedLib {-# LINE 13021 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 50, column 9) _tlOenvUpdates = {-# LINE 50 "./TypeChecking/Statements.ag" #-} _hdIenvUpdates {-# LINE 13026 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 51, column 9) _tlOlibUpdates = {-# LINE 51 "./TypeChecking/Statements.ag" #-} _hdIlibUpdates {-# LINE 13031 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 76, column 12) _hdOinProducedEnv = {-# LINE 76 "./TypeChecking/Statements.ag" #-} _tlIproducedEnv {-# LINE 13036 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} (:) _hdIannotatedTree _tlIannotatedTree {-# LINE 13041 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} (:) _hdIoriginalTree _tlIoriginalTree {-# LINE 13046 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 13051 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 13056 "AstInternal.hs" #-} ( _hdIannotatedTree,_hdIenvUpdates,_hdIlibUpdates,_hdIoriginalTree) = (hd_ _hdOenv _hdOinProducedEnv _hdOlib ) ( _tlIannotatedTree,_tlIoriginalTree,_tlIproducedEnv,_tlIproducedLib) = (tl_ _tlOenv _tlOenvUpdates _tlOlib _tlOlibUpdates ) in ( _lhsOannotatedTree,_lhsOoriginalTree,_lhsOproducedEnv,_lhsOproducedLib))) sem_StatementList_Nil :: T_StatementList sem_StatementList_Nil = (\ _lhsIenv _lhsIenvUpdates _lhsIlib _lhsIlibUpdates -> (let _lhsOproducedEnv :: Environment _lhsOproducedLib :: LocalIdentifierBindings _lhsOannotatedTree :: StatementList _lhsOoriginalTree :: StatementList -- "./TypeChecking/Statements.ag"(line 36, column 9) _newEnv = {-# LINE 36 "./TypeChecking/Statements.ag" #-} fromRight _lhsIenv $ updateEnvironment _lhsIenv _lhsIenvUpdates {-# LINE 13076 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 37, column 9) _newLib = {-# LINE 37 "./TypeChecking/Statements.ag" #-} fromRight _lhsIlib $ updateBindings _lhsIlib _lhsIenv _lhsIlibUpdates {-# LINE 13081 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 53, column 9) _lhsOproducedEnv = {-# LINE 53 "./TypeChecking/Statements.ag" #-} _newEnv {-# LINE 13086 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 54, column 9) _lhsOproducedLib = {-# LINE 54 "./TypeChecking/Statements.ag" #-} _newLib {-# LINE 13091 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 13096 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 13101 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 13106 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 13111 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree,_lhsOproducedEnv,_lhsOproducedLib))) -- StringList -------------------------------------------------- {- visit 0: inherited attributes: env : Environment lib : LocalIdentifierBindings synthesized attributes: annotatedTree : SELF originalTree : SELF strings : [String] alternatives: alternative Cons: child hd : {String} child tl : StringList visit 0: local annotatedTree : _ local originalTree : _ alternative Nil: visit 0: local annotatedTree : _ local originalTree : _ -} type StringList = [(String)] -- cata sem_StringList :: StringList -> T_StringList sem_StringList list = (Prelude.foldr sem_StringList_Cons sem_StringList_Nil list ) -- semantic domain type T_StringList = Environment -> LocalIdentifierBindings -> ( StringList,StringList,([String])) data Inh_StringList = Inh_StringList {env_Inh_StringList :: Environment,lib_Inh_StringList :: LocalIdentifierBindings} data Syn_StringList = Syn_StringList {annotatedTree_Syn_StringList :: StringList,originalTree_Syn_StringList :: StringList,strings_Syn_StringList :: [String]} wrap_StringList :: T_StringList -> Inh_StringList -> Syn_StringList wrap_StringList sem (Inh_StringList _lhsIenv _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree,_lhsOstrings) = (sem _lhsIenv _lhsIlib ) in (Syn_StringList _lhsOannotatedTree _lhsOoriginalTree _lhsOstrings )) sem_StringList_Cons :: String -> T_StringList -> T_StringList sem_StringList_Cons hd_ tl_ = (\ _lhsIenv _lhsIlib -> (let _lhsOstrings :: ([String]) _lhsOannotatedTree :: StringList _lhsOoriginalTree :: StringList _tlOenv :: Environment _tlOlib :: LocalIdentifierBindings _tlIannotatedTree :: StringList _tlIoriginalTree :: StringList _tlIstrings :: ([String]) -- "./TypeChecking/Misc.ag"(line 67, column 10) _lhsOstrings = {-# LINE 67 "./TypeChecking/Misc.ag" #-} hd_ : _tlIstrings {-# LINE 13172 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} (:) hd_ _tlIannotatedTree {-# LINE 13177 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} (:) hd_ _tlIoriginalTree {-# LINE 13182 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 13187 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 13192 "AstInternal.hs" #-} -- copy rule (down) _tlOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 13197 "AstInternal.hs" #-} -- copy rule (down) _tlOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 13202 "AstInternal.hs" #-} ( _tlIannotatedTree,_tlIoriginalTree,_tlIstrings) = (tl_ _tlOenv _tlOlib ) in ( _lhsOannotatedTree,_lhsOoriginalTree,_lhsOstrings))) sem_StringList_Nil :: T_StringList sem_StringList_Nil = (\ _lhsIenv _lhsIlib -> (let _lhsOstrings :: ([String]) _lhsOannotatedTree :: StringList _lhsOoriginalTree :: StringList -- "./TypeChecking/Misc.ag"(line 68, column 9) _lhsOstrings = {-# LINE 68 "./TypeChecking/Misc.ag" #-} [] {-# LINE 13217 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 13222 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 13227 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 13232 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 13237 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree,_lhsOstrings))) -- StringTypeNameListPair -------------------------------------- {- visit 0: inherited attributes: env : Environment lib : LocalIdentifierBindings synthesized attributes: annotatedTree : SELF fnSig : (String,[Type]) originalTree : SELF alternatives: alternative Tuple: child x1 : {String} child x2 : TypeNameList visit 0: local annotatedTree : _ local originalTree : _ -} type StringTypeNameListPair = ( (String),(TypeNameList)) -- cata sem_StringTypeNameListPair :: StringTypeNameListPair -> T_StringTypeNameListPair sem_StringTypeNameListPair ( x1,x2) = (sem_StringTypeNameListPair_Tuple x1 (sem_TypeNameList x2 ) ) -- semantic domain type T_StringTypeNameListPair = Environment -> LocalIdentifierBindings -> ( StringTypeNameListPair,((String,[Type])),StringTypeNameListPair) data Inh_StringTypeNameListPair = Inh_StringTypeNameListPair {env_Inh_StringTypeNameListPair :: Environment,lib_Inh_StringTypeNameListPair :: LocalIdentifierBindings} data Syn_StringTypeNameListPair = Syn_StringTypeNameListPair {annotatedTree_Syn_StringTypeNameListPair :: StringTypeNameListPair,fnSig_Syn_StringTypeNameListPair :: (String,[Type]),originalTree_Syn_StringTypeNameListPair :: StringTypeNameListPair} wrap_StringTypeNameListPair :: T_StringTypeNameListPair -> Inh_StringTypeNameListPair -> Syn_StringTypeNameListPair wrap_StringTypeNameListPair sem (Inh_StringTypeNameListPair _lhsIenv _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOfnSig,_lhsOoriginalTree) = (sem _lhsIenv _lhsIlib ) in (Syn_StringTypeNameListPair _lhsOannotatedTree _lhsOfnSig _lhsOoriginalTree )) sem_StringTypeNameListPair_Tuple :: String -> T_TypeNameList -> T_StringTypeNameListPair sem_StringTypeNameListPair_Tuple x1_ x2_ = (\ _lhsIenv _lhsIlib -> (let _lhsOfnSig :: ((String,[Type])) _lhsOannotatedTree :: StringTypeNameListPair _lhsOoriginalTree :: StringTypeNameListPair _x2Oenv :: Environment _x2Olib :: LocalIdentifierBindings _x2IannotatedTree :: TypeNameList _x2InamedTypes :: ([Type]) _x2IoriginalTree :: TypeNameList -- "./TypeChecking/Drops.ag"(line 25, column 13) _lhsOfnSig = {-# LINE 25 "./TypeChecking/Drops.ag" #-} (x1_, _x2InamedTypes) {-# LINE 13294 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} (x1_,_x2IannotatedTree) {-# LINE 13299 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} (x1_,_x2IoriginalTree) {-# LINE 13304 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 13309 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 13314 "AstInternal.hs" #-} -- copy rule (down) _x2Oenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 13319 "AstInternal.hs" #-} -- copy rule (down) _x2Olib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 13324 "AstInternal.hs" #-} ( _x2IannotatedTree,_x2InamedTypes,_x2IoriginalTree) = (x2_ _x2Oenv _x2Olib ) in ( _lhsOannotatedTree,_lhsOfnSig,_lhsOoriginalTree))) -- StringTypeNameListPairList ---------------------------------- {- visit 0: inherited attributes: env : Environment lib : LocalIdentifierBindings synthesized attributes: annotatedTree : SELF fnSigs : [(String,[Type])] originalTree : SELF alternatives: alternative Cons: child hd : StringTypeNameListPair child tl : StringTypeNameListPairList visit 0: local annotatedTree : _ local originalTree : _ alternative Nil: visit 0: local annotatedTree : _ local originalTree : _ -} type StringTypeNameListPairList = [(StringTypeNameListPair)] -- cata sem_StringTypeNameListPairList :: StringTypeNameListPairList -> T_StringTypeNameListPairList sem_StringTypeNameListPairList list = (Prelude.foldr sem_StringTypeNameListPairList_Cons sem_StringTypeNameListPairList_Nil (Prelude.map sem_StringTypeNameListPair list) ) -- semantic domain type T_StringTypeNameListPairList = Environment -> LocalIdentifierBindings -> ( StringTypeNameListPairList,([(String,[Type])]),StringTypeNameListPairList) data Inh_StringTypeNameListPairList = Inh_StringTypeNameListPairList {env_Inh_StringTypeNameListPairList :: Environment,lib_Inh_StringTypeNameListPairList :: LocalIdentifierBindings} data Syn_StringTypeNameListPairList = Syn_StringTypeNameListPairList {annotatedTree_Syn_StringTypeNameListPairList :: StringTypeNameListPairList,fnSigs_Syn_StringTypeNameListPairList :: [(String,[Type])],originalTree_Syn_StringTypeNameListPairList :: StringTypeNameListPairList} wrap_StringTypeNameListPairList :: T_StringTypeNameListPairList -> Inh_StringTypeNameListPairList -> Syn_StringTypeNameListPairList wrap_StringTypeNameListPairList sem (Inh_StringTypeNameListPairList _lhsIenv _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOfnSigs,_lhsOoriginalTree) = (sem _lhsIenv _lhsIlib ) in (Syn_StringTypeNameListPairList _lhsOannotatedTree _lhsOfnSigs _lhsOoriginalTree )) sem_StringTypeNameListPairList_Cons :: T_StringTypeNameListPair -> T_StringTypeNameListPairList -> T_StringTypeNameListPairList sem_StringTypeNameListPairList_Cons hd_ tl_ = (\ _lhsIenv _lhsIlib -> (let _lhsOfnSigs :: ([(String,[Type])]) _lhsOannotatedTree :: StringTypeNameListPairList _lhsOoriginalTree :: StringTypeNameListPairList _hdOenv :: Environment _hdOlib :: LocalIdentifierBindings _tlOenv :: Environment _tlOlib :: LocalIdentifierBindings _hdIannotatedTree :: StringTypeNameListPair _hdIfnSig :: ((String,[Type])) _hdIoriginalTree :: StringTypeNameListPair _tlIannotatedTree :: StringTypeNameListPairList _tlIfnSigs :: ([(String,[Type])]) _tlIoriginalTree :: StringTypeNameListPairList -- "./TypeChecking/Drops.ag"(line 20, column 12) _lhsOfnSigs = {-# LINE 20 "./TypeChecking/Drops.ag" #-} _hdIfnSig : _tlIfnSigs {-# LINE 13392 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} (:) _hdIannotatedTree _tlIannotatedTree {-# LINE 13397 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} (:) _hdIoriginalTree _tlIoriginalTree {-# LINE 13402 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 13407 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 13412 "AstInternal.hs" #-} -- copy rule (down) _hdOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 13417 "AstInternal.hs" #-} -- copy rule (down) _hdOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 13422 "AstInternal.hs" #-} -- copy rule (down) _tlOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 13427 "AstInternal.hs" #-} -- copy rule (down) _tlOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 13432 "AstInternal.hs" #-} ( _hdIannotatedTree,_hdIfnSig,_hdIoriginalTree) = (hd_ _hdOenv _hdOlib ) ( _tlIannotatedTree,_tlIfnSigs,_tlIoriginalTree) = (tl_ _tlOenv _tlOlib ) in ( _lhsOannotatedTree,_lhsOfnSigs,_lhsOoriginalTree))) sem_StringTypeNameListPairList_Nil :: T_StringTypeNameListPairList sem_StringTypeNameListPairList_Nil = (\ _lhsIenv _lhsIlib -> (let _lhsOfnSigs :: ([(String,[Type])]) _lhsOannotatedTree :: StringTypeNameListPairList _lhsOoriginalTree :: StringTypeNameListPairList -- "./TypeChecking/Drops.ag"(line 21, column 11) _lhsOfnSigs = {-# LINE 21 "./TypeChecking/Drops.ag" #-} [] {-# LINE 13449 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 13454 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 13459 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 13464 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 13469 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOfnSigs,_lhsOoriginalTree))) -- TableAlias -------------------------------------------------- {- visit 0: inherited attributes: env : Environment lib : LocalIdentifierBindings synthesized attributes: annotatedTree : SELF originalTree : SELF alternatives: alternative FullAlias: child alias : {String} child cols : {[String]} visit 0: local annotatedTree : _ local originalTree : _ alternative NoAlias: visit 0: local annotatedTree : _ local originalTree : _ alternative TableAlias: child alias : {String} visit 0: local annotatedTree : _ local originalTree : _ -} data TableAlias = FullAlias (String) ([String]) | NoAlias | TableAlias (String) deriving ( Data,Eq,Show,Typeable) -- cata sem_TableAlias :: TableAlias -> T_TableAlias sem_TableAlias (FullAlias _alias _cols ) = (sem_TableAlias_FullAlias _alias _cols ) sem_TableAlias (NoAlias ) = (sem_TableAlias_NoAlias ) sem_TableAlias (TableAlias _alias ) = (sem_TableAlias_TableAlias _alias ) -- semantic domain type T_TableAlias = Environment -> LocalIdentifierBindings -> ( TableAlias,TableAlias) data Inh_TableAlias = Inh_TableAlias {env_Inh_TableAlias :: Environment,lib_Inh_TableAlias :: LocalIdentifierBindings} data Syn_TableAlias = Syn_TableAlias {annotatedTree_Syn_TableAlias :: TableAlias,originalTree_Syn_TableAlias :: TableAlias} wrap_TableAlias :: T_TableAlias -> Inh_TableAlias -> Syn_TableAlias wrap_TableAlias sem (Inh_TableAlias _lhsIenv _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIenv _lhsIlib ) in (Syn_TableAlias _lhsOannotatedTree _lhsOoriginalTree )) sem_TableAlias_FullAlias :: String -> ([String]) -> T_TableAlias sem_TableAlias_FullAlias alias_ cols_ = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: TableAlias _lhsOoriginalTree :: TableAlias -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} FullAlias alias_ cols_ {-# LINE 13535 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} FullAlias alias_ cols_ {-# LINE 13540 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 13545 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 13550 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_TableAlias_NoAlias :: T_TableAlias sem_TableAlias_NoAlias = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: TableAlias _lhsOoriginalTree :: TableAlias -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} NoAlias {-# LINE 13562 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} NoAlias {-# LINE 13567 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 13572 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 13577 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_TableAlias_TableAlias :: String -> T_TableAlias sem_TableAlias_TableAlias alias_ = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: TableAlias _lhsOoriginalTree :: TableAlias -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} TableAlias alias_ {-# LINE 13590 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} TableAlias alias_ {-# LINE 13595 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 13600 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 13605 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) -- TableRef ---------------------------------------------------- {- visit 0: inherited attributes: env : Environment jlibUpdates : [LocalIdentifierBindingsUpdate] lib : LocalIdentifierBindings synthesized attributes: annotatedTree : SELF idLookups : [(String,Type)] libUpdates : [LocalIdentifierBindingsUpdate] originalTree : SELF qidLookups : [(String,[(String,Type)])] qstarExpansion : [(String,[(String,Type)])] starExpansion : [(String,Type)] alternatives: alternative JoinedTref: child ann : {Annotation} child tbl : TableRef child nat : Natural child joinType : JoinType child tbl1 : TableRef child onExpr : OnExpr child alias : TableAlias visit 0: local libUpdates : _ local errs : _ local removeJoinAttrs : _ local ejoinAttrs : {Either [TypeError] [(String,Type)]} local joinNames : _ local joinAttrs : _ local idLookups : {[(String,Type)]} local qidLookups : {[(String,[(String,Type)])]} local starExpansion : {[(String,Type)]} local qstarExpansion : {[(String,[(String,Type)])]} local newLib : _ local backTree : _ local annotatedTree : _ local originalTree : _ alternative SubTref: child ann : {Annotation} child sel : SelectExpression child alias : TableAlias visit 0: local libUpdates : _ local errs : _ local selectAttrs : {Either [TypeError] [(String,Type)]} local idLookups : {[(String,Type)]} local qidLookups : {[(String,[(String,Type)])]} local starExpansion : {[(String,Type)]} local qstarExpansion : {[(String,[(String,Type)])]} local backTree : _ local annotatedTree : _ local originalTree : _ alternative Tref: child ann : {Annotation} child tbl : {String} child alias : TableAlias visit 0: local libUpdates : _ local errs : _ local relType : {Either [TypeError] ([(String, Type)], [(String, Type)])} local relType1 : _ local pAttrs : _ local sAttrs : _ local idLookups : {[(String,Type)]} local alias : _ local qidLookups : {[(String,[(String,Type)])]} local starExpansion : {[(String,Type)]} local qstarExpansion : {[(String,[(String,Type)])]} local backTree : _ local annotatedTree : _ local originalTree : _ alternative TrefFun: child ann : {Annotation} child fn : Expression child alias : TableAlias visit 0: local libUpdates : _ local errs : _ local eqfunIdens : {Either [TypeError] (String,[(String,Type)])} local qfunIdens : _ local alias2 : _ local funIdens : _ local alias : _ local idLookups : {[(String,Type)]} local qidLookups : {[(String,[(String,Type)])]} local starExpansion : {[(String,Type)]} local qstarExpansion : {[(String,[(String,Type)])]} local backTree : _ local annotatedTree : _ local originalTree : _ -} data TableRef = JoinedTref (Annotation) (TableRef) (Natural) (JoinType) (TableRef) (OnExpr) (TableAlias) | SubTref (Annotation) (SelectExpression) (TableAlias) | Tref (Annotation) (String) (TableAlias) | TrefFun (Annotation) (Expression) (TableAlias) deriving ( Data,Eq,Show,Typeable) -- cata sem_TableRef :: TableRef -> T_TableRef sem_TableRef (JoinedTref _ann _tbl _nat _joinType _tbl1 _onExpr _alias ) = (sem_TableRef_JoinedTref _ann (sem_TableRef _tbl ) (sem_Natural _nat ) (sem_JoinType _joinType ) (sem_TableRef _tbl1 ) (sem_OnExpr _onExpr ) (sem_TableAlias _alias ) ) sem_TableRef (SubTref _ann _sel _alias ) = (sem_TableRef_SubTref _ann (sem_SelectExpression _sel ) (sem_TableAlias _alias ) ) sem_TableRef (Tref _ann _tbl _alias ) = (sem_TableRef_Tref _ann _tbl (sem_TableAlias _alias ) ) sem_TableRef (TrefFun _ann _fn _alias ) = (sem_TableRef_TrefFun _ann (sem_Expression _fn ) (sem_TableAlias _alias ) ) -- semantic domain type T_TableRef = Environment -> ([LocalIdentifierBindingsUpdate]) -> LocalIdentifierBindings -> ( TableRef,([(String,Type)]),([LocalIdentifierBindingsUpdate]),TableRef,([(String,[(String,Type)])]),([(String,[(String,Type)])]),([(String,Type)])) data Inh_TableRef = Inh_TableRef {env_Inh_TableRef :: Environment,jlibUpdates_Inh_TableRef :: [LocalIdentifierBindingsUpdate],lib_Inh_TableRef :: LocalIdentifierBindings} data Syn_TableRef = Syn_TableRef {annotatedTree_Syn_TableRef :: TableRef,idLookups_Syn_TableRef :: [(String,Type)],libUpdates_Syn_TableRef :: [LocalIdentifierBindingsUpdate],originalTree_Syn_TableRef :: TableRef,qidLookups_Syn_TableRef :: [(String,[(String,Type)])],qstarExpansion_Syn_TableRef :: [(String,[(String,Type)])],starExpansion_Syn_TableRef :: [(String,Type)]} wrap_TableRef :: T_TableRef -> Inh_TableRef -> Syn_TableRef wrap_TableRef sem (Inh_TableRef _lhsIenv _lhsIjlibUpdates _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOidLookups,_lhsOlibUpdates,_lhsOoriginalTree,_lhsOqidLookups,_lhsOqstarExpansion,_lhsOstarExpansion) = (sem _lhsIenv _lhsIjlibUpdates _lhsIlib ) in (Syn_TableRef _lhsOannotatedTree _lhsOidLookups _lhsOlibUpdates _lhsOoriginalTree _lhsOqidLookups _lhsOqstarExpansion _lhsOstarExpansion )) sem_TableRef_JoinedTref :: Annotation -> T_TableRef -> T_Natural -> T_JoinType -> T_TableRef -> T_OnExpr -> T_TableAlias -> T_TableRef sem_TableRef_JoinedTref ann_ tbl_ nat_ joinType_ tbl1_ onExpr_ alias_ = (\ _lhsIenv _lhsIjlibUpdates _lhsIlib -> (let _lhsOannotatedTree :: TableRef _ejoinAttrs :: (Either [TypeError] [(String,Type)]) _idLookups :: ([(String,Type)]) _qidLookups :: ([(String,[(String,Type)])]) _starExpansion :: ([(String,Type)]) _qstarExpansion :: ([(String,[(String,Type)])]) _onExprOlib :: LocalIdentifierBindings _tblOjlibUpdates :: ([LocalIdentifierBindingsUpdate]) _tbl1OjlibUpdates :: ([LocalIdentifierBindingsUpdate]) _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _lhsOidLookups :: ([(String,Type)]) _lhsOqidLookups :: ([(String,[(String,Type)])]) _lhsOstarExpansion :: ([(String,Type)]) _lhsOqstarExpansion :: ([(String,[(String,Type)])]) _lhsOoriginalTree :: TableRef _tblOenv :: Environment _tblOlib :: LocalIdentifierBindings _natOenv :: Environment _natOlib :: LocalIdentifierBindings _joinTypeOenv :: Environment _joinTypeOlib :: LocalIdentifierBindings _tbl1Oenv :: Environment _tbl1Olib :: LocalIdentifierBindings _onExprOenv :: Environment _aliasOenv :: Environment _aliasOlib :: LocalIdentifierBindings _tblIannotatedTree :: TableRef _tblIidLookups :: ([(String,Type)]) _tblIlibUpdates :: ([LocalIdentifierBindingsUpdate]) _tblIoriginalTree :: TableRef _tblIqidLookups :: ([(String,[(String,Type)])]) _tblIqstarExpansion :: ([(String,[(String,Type)])]) _tblIstarExpansion :: ([(String,Type)]) _natIannotatedTree :: Natural _natIoriginalTree :: Natural _joinTypeIannotatedTree :: JoinType _joinTypeIoriginalTree :: JoinType _tbl1IannotatedTree :: TableRef _tbl1IidLookups :: ([(String,Type)]) _tbl1IlibUpdates :: ([LocalIdentifierBindingsUpdate]) _tbl1IoriginalTree :: TableRef _tbl1IqidLookups :: ([(String,[(String,Type)])]) _tbl1IqstarExpansion :: ([(String,[(String,Type)])]) _tbl1IstarExpansion :: ([(String,Type)]) _onExprIannotatedTree :: OnExpr _onExprIoriginalTree :: OnExpr _aliasIannotatedTree :: TableAlias _aliasIoriginalTree :: TableAlias -- "./TypeChecking/TableRefs.ag"(line 33, column 9) _lhsOannotatedTree = {-# LINE 33 "./TypeChecking/TableRefs.ag" #-} updateAnnotation (map TypeErrorA _errs ++) _backTree {-# LINE 13794 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 75, column 9) _libUpdates = {-# LINE 75 "./TypeChecking/TableRefs.ag" #-} if null _errs then [LibStackIDs $ ("", _idLookups ): _qidLookups ,LibSetStarExpansion $ ("", _starExpansion ): _qstarExpansion ] else [] {-# LINE 13802 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 135, column 9) _errs = {-# LINE 135 "./TypeChecking/TableRefs.ag" #-} fromLeft [] _ejoinAttrs {-# LINE 13807 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 136, column 9) _removeJoinAttrs = {-# LINE 136 "./TypeChecking/TableRefs.ag" #-} filter (\(n,_) -> n `notElem` _joinNames ) {-# LINE 13812 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 146, column 9) _ejoinAttrs = {-# LINE 146 "./TypeChecking/TableRefs.ag" #-} do let jns = case (_natIannotatedTree, _onExprIoriginalTree) of (Natural, _) -> commonFieldNames (_,Just (JoinUsing _ s)) -> s _ -> [] tjtsm = map (flip lookup _tblIidLookups) jns t1jtsm = map (flip lookup _tbl1IidLookups) jns errorWhen (not $ null $ filter (==Nothing) $ tjtsm ++ t1jtsm) [MissingJoinAttribute] let tjts = catMaybes tjtsm t1jts = catMaybes t1jtsm resolvedTypes :: [Either [TypeError] Type] resolvedTypes = map (\(a,b) -> resolveResultSetType _lhsIenv [a,b]) $ zip tjts t1jts liftErrors $ concat $ lefts resolvedTypes return $ zip jns $ rights resolvedTypes where commonFieldNames = intersect (f _tblIstarExpansion) (f _tbl1IstarExpansion) where f = map fst {-# LINE 13834 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 170, column 9) _joinNames = {-# LINE 170 "./TypeChecking/TableRefs.ag" #-} map fst _joinAttrs {-# LINE 13839 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 171, column 9) _joinAttrs = {-# LINE 171 "./TypeChecking/TableRefs.ag" #-} fromRight [] _ejoinAttrs {-# LINE 13844 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 176, column 9) _idLookups = {-# LINE 176 "./TypeChecking/TableRefs.ag" #-} _joinAttrs ++ _removeJoinAttrs _tblIidLookups ++ _removeJoinAttrs _tbl1IidLookups {-# LINE 13851 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 179, column 9) _qidLookups = {-# LINE 179 "./TypeChecking/TableRefs.ag" #-} _tblIqidLookups ++ _tbl1IqidLookups {-# LINE 13856 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 180, column 9) _starExpansion = {-# LINE 180 "./TypeChecking/TableRefs.ag" #-} _joinAttrs ++ _removeJoinAttrs _tblIstarExpansion ++ _removeJoinAttrs _tbl1IstarExpansion {-# LINE 13863 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 183, column 9) _qstarExpansion = {-# LINE 183 "./TypeChecking/TableRefs.ag" #-} _tblIqstarExpansion ++ _tbl1IqstarExpansion {-# LINE 13868 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 187, column 9) _newLib = {-# LINE 187 "./TypeChecking/TableRefs.ag" #-} case updateBindings _lhsIlib _lhsIenv (_libUpdates ++ _lhsIjlibUpdates) of Left x -> error $ show x Right e -> e {-# LINE 13875 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 190, column 9) _onExprOlib = {-# LINE 190 "./TypeChecking/TableRefs.ag" #-} _newLib {-# LINE 13880 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 192, column 9) _tblOjlibUpdates = {-# LINE 192 "./TypeChecking/TableRefs.ag" #-} _libUpdates {-# LINE 13885 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 193, column 9) _tbl1OjlibUpdates = {-# LINE 193 "./TypeChecking/TableRefs.ag" #-} _libUpdates {-# LINE 13890 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 248, column 9) _lhsOlibUpdates = {-# LINE 248 "./TypeChecking/TableRefs.ag" #-} _libUpdates {-# LINE 13895 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 249, column 9) _lhsOidLookups = {-# LINE 249 "./TypeChecking/TableRefs.ag" #-} _idLookups {-# LINE 13900 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 250, column 9) _lhsOqidLookups = {-# LINE 250 "./TypeChecking/TableRefs.ag" #-} _qidLookups {-# LINE 13905 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 251, column 9) _lhsOstarExpansion = {-# LINE 251 "./TypeChecking/TableRefs.ag" #-} _starExpansion {-# LINE 13910 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 252, column 9) _lhsOqstarExpansion = {-# LINE 252 "./TypeChecking/TableRefs.ag" #-} _qstarExpansion {-# LINE 13915 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 264, column 9) _backTree = {-# LINE 264 "./TypeChecking/TableRefs.ag" #-} JoinedTref ann_ _tblIannotatedTree _natIannotatedTree _joinTypeIannotatedTree _tbl1IannotatedTree _onExprIannotatedTree _aliasIannotatedTree {-# LINE 13926 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} JoinedTref ann_ _tblIannotatedTree _natIannotatedTree _joinTypeIannotatedTree _tbl1IannotatedTree _onExprIannotatedTree _aliasIannotatedTree {-# LINE 13931 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} JoinedTref ann_ _tblIoriginalTree _natIoriginalTree _joinTypeIoriginalTree _tbl1IoriginalTree _onExprIoriginalTree _aliasIoriginalTree {-# LINE 13936 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 13941 "AstInternal.hs" #-} -- copy rule (down) _tblOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 13946 "AstInternal.hs" #-} -- copy rule (down) _tblOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 13951 "AstInternal.hs" #-} -- copy rule (down) _natOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 13956 "AstInternal.hs" #-} -- copy rule (down) _natOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 13961 "AstInternal.hs" #-} -- copy rule (down) _joinTypeOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 13966 "AstInternal.hs" #-} -- copy rule (down) _joinTypeOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 13971 "AstInternal.hs" #-} -- copy rule (down) _tbl1Oenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 13976 "AstInternal.hs" #-} -- copy rule (down) _tbl1Olib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 13981 "AstInternal.hs" #-} -- copy rule (down) _onExprOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 13986 "AstInternal.hs" #-} -- copy rule (down) _aliasOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 13991 "AstInternal.hs" #-} -- copy rule (down) _aliasOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 13996 "AstInternal.hs" #-} ( _tblIannotatedTree,_tblIidLookups,_tblIlibUpdates,_tblIoriginalTree,_tblIqidLookups,_tblIqstarExpansion,_tblIstarExpansion) = (tbl_ _tblOenv _tblOjlibUpdates _tblOlib ) ( _natIannotatedTree,_natIoriginalTree) = (nat_ _natOenv _natOlib ) ( _joinTypeIannotatedTree,_joinTypeIoriginalTree) = (joinType_ _joinTypeOenv _joinTypeOlib ) ( _tbl1IannotatedTree,_tbl1IidLookups,_tbl1IlibUpdates,_tbl1IoriginalTree,_tbl1IqidLookups,_tbl1IqstarExpansion,_tbl1IstarExpansion) = (tbl1_ _tbl1Oenv _tbl1OjlibUpdates _tbl1Olib ) ( _onExprIannotatedTree,_onExprIoriginalTree) = (onExpr_ _onExprOenv _onExprOlib ) ( _aliasIannotatedTree,_aliasIoriginalTree) = (alias_ _aliasOenv _aliasOlib ) in ( _lhsOannotatedTree,_lhsOidLookups,_lhsOlibUpdates,_lhsOoriginalTree,_lhsOqidLookups,_lhsOqstarExpansion,_lhsOstarExpansion))) sem_TableRef_SubTref :: Annotation -> T_SelectExpression -> T_TableAlias -> T_TableRef sem_TableRef_SubTref ann_ sel_ alias_ = (\ _lhsIenv _lhsIjlibUpdates _lhsIlib -> (let _lhsOannotatedTree :: TableRef _selectAttrs :: (Either [TypeError] [(String,Type)]) _idLookups :: ([(String,Type)]) _qidLookups :: ([(String,[(String,Type)])]) _starExpansion :: ([(String,Type)]) _qstarExpansion :: ([(String,[(String,Type)])]) _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _lhsOidLookups :: ([(String,Type)]) _lhsOqidLookups :: ([(String,[(String,Type)])]) _lhsOstarExpansion :: ([(String,Type)]) _lhsOqstarExpansion :: ([(String,[(String,Type)])]) _lhsOoriginalTree :: TableRef _selOenv :: Environment _selOlib :: LocalIdentifierBindings _aliasOenv :: Environment _aliasOlib :: LocalIdentifierBindings _selIannotatedTree :: SelectExpression _selIlibUpdates :: ([LocalIdentifierBindingsUpdate]) _selIoriginalTree :: SelectExpression _aliasIannotatedTree :: TableAlias _aliasIoriginalTree :: TableAlias -- "./TypeChecking/TableRefs.ag"(line 33, column 9) _lhsOannotatedTree = {-# LINE 33 "./TypeChecking/TableRefs.ag" #-} updateAnnotation (map TypeErrorA _errs ++) _backTree {-# LINE 14043 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 75, column 9) _libUpdates = {-# LINE 75 "./TypeChecking/TableRefs.ag" #-} if null _errs then [LibStackIDs $ ("", _idLookups ): _qidLookups ,LibSetStarExpansion $ ("", _starExpansion ): _qstarExpansion ] else [] {-# LINE 14051 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 92, column 9) _errs = {-# LINE 92 "./TypeChecking/TableRefs.ag" #-} case _selectAttrs of Left e -> e Right _ -> [] {-# LINE 14058 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 96, column 9) _selectAttrs = {-# LINE 96 "./TypeChecking/TableRefs.ag" #-} unwrapSetOfComposite (getTypeAnnotation _selIannotatedTree) {-# LINE 14063 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 98, column 9) _idLookups = {-# LINE 98 "./TypeChecking/TableRefs.ag" #-} fromRight [] _selectAttrs {-# LINE 14068 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 99, column 9) _qidLookups = {-# LINE 99 "./TypeChecking/TableRefs.ag" #-} [(getAlias "" _aliasIannotatedTree, _idLookups )] {-# LINE 14073 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 100, column 9) _starExpansion = {-# LINE 100 "./TypeChecking/TableRefs.ag" #-} _idLookups {-# LINE 14078 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 101, column 9) _qstarExpansion = {-# LINE 101 "./TypeChecking/TableRefs.ag" #-} _qidLookups {-# LINE 14083 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 248, column 9) _lhsOlibUpdates = {-# LINE 248 "./TypeChecking/TableRefs.ag" #-} _libUpdates {-# LINE 14088 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 249, column 9) _lhsOidLookups = {-# LINE 249 "./TypeChecking/TableRefs.ag" #-} _idLookups {-# LINE 14093 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 250, column 9) _lhsOqidLookups = {-# LINE 250 "./TypeChecking/TableRefs.ag" #-} _qidLookups {-# LINE 14098 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 251, column 9) _lhsOstarExpansion = {-# LINE 251 "./TypeChecking/TableRefs.ag" #-} _starExpansion {-# LINE 14103 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 252, column 9) _lhsOqstarExpansion = {-# LINE 252 "./TypeChecking/TableRefs.ag" #-} _qstarExpansion {-# LINE 14108 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 258, column 9) _backTree = {-# LINE 258 "./TypeChecking/TableRefs.ag" #-} SubTref ann_ _selIannotatedTree _aliasIannotatedTree {-# LINE 14113 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} SubTref ann_ _selIannotatedTree _aliasIannotatedTree {-# LINE 14118 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} SubTref ann_ _selIoriginalTree _aliasIoriginalTree {-# LINE 14123 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 14128 "AstInternal.hs" #-} -- copy rule (down) _selOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 14133 "AstInternal.hs" #-} -- copy rule (down) _selOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 14138 "AstInternal.hs" #-} -- copy rule (down) _aliasOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 14143 "AstInternal.hs" #-} -- copy rule (down) _aliasOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 14148 "AstInternal.hs" #-} ( _selIannotatedTree,_selIlibUpdates,_selIoriginalTree) = (sel_ _selOenv _selOlib ) ( _aliasIannotatedTree,_aliasIoriginalTree) = (alias_ _aliasOenv _aliasOlib ) in ( _lhsOannotatedTree,_lhsOidLookups,_lhsOlibUpdates,_lhsOoriginalTree,_lhsOqidLookups,_lhsOqstarExpansion,_lhsOstarExpansion))) sem_TableRef_Tref :: Annotation -> String -> T_TableAlias -> T_TableRef sem_TableRef_Tref ann_ tbl_ alias_ = (\ _lhsIenv _lhsIjlibUpdates _lhsIlib -> (let _lhsOannotatedTree :: TableRef _relType :: (Either [TypeError] ([(String, Type)], [(String, Type)])) _idLookups :: ([(String,Type)]) _qidLookups :: ([(String,[(String,Type)])]) _starExpansion :: ([(String,Type)]) _qstarExpansion :: ([(String,[(String,Type)])]) _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _lhsOidLookups :: ([(String,Type)]) _lhsOqidLookups :: ([(String,[(String,Type)])]) _lhsOstarExpansion :: ([(String,Type)]) _lhsOqstarExpansion :: ([(String,[(String,Type)])]) _lhsOoriginalTree :: TableRef _aliasOenv :: Environment _aliasOlib :: LocalIdentifierBindings _aliasIannotatedTree :: TableAlias _aliasIoriginalTree :: TableAlias -- "./TypeChecking/TableRefs.ag"(line 33, column 9) _lhsOannotatedTree = {-# LINE 33 "./TypeChecking/TableRefs.ag" #-} updateAnnotation (map TypeErrorA _errs ++) _backTree {-# LINE 14182 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 75, column 9) _libUpdates = {-# LINE 75 "./TypeChecking/TableRefs.ag" #-} if null _errs then [LibStackIDs $ ("", _idLookups ): _qidLookups ,LibSetStarExpansion $ ("", _starExpansion ): _qstarExpansion ] else [] {-# LINE 14190 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 104, column 9) _errs = {-# LINE 104 "./TypeChecking/TableRefs.ag" #-} case _relType of Left e -> e Right _ -> [] {-# LINE 14197 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 108, column 9) _relType = {-# LINE 108 "./TypeChecking/TableRefs.ag" #-} envCompositeAttrsPair _lhsIenv [] tbl_ {-# LINE 14202 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 109, column 9) _relType1 = {-# LINE 109 "./TypeChecking/TableRefs.ag" #-} fromRight ([],[]) _relType {-# LINE 14207 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 110, column 9) _pAttrs = {-# LINE 110 "./TypeChecking/TableRefs.ag" #-} fst _relType1 {-# LINE 14212 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 111, column 9) _sAttrs = {-# LINE 111 "./TypeChecking/TableRefs.ag" #-} snd _relType1 {-# LINE 14217 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 113, column 9) _idLookups = {-# LINE 113 "./TypeChecking/TableRefs.ag" #-} _pAttrs ++ _sAttrs {-# LINE 14222 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 114, column 9) _alias = {-# LINE 114 "./TypeChecking/TableRefs.ag" #-} getAlias tbl_ _aliasIannotatedTree {-# LINE 14227 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 115, column 9) _qidLookups = {-# LINE 115 "./TypeChecking/TableRefs.ag" #-} [(_alias , _idLookups )] {-# LINE 14232 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 116, column 9) _starExpansion = {-# LINE 116 "./TypeChecking/TableRefs.ag" #-} _pAttrs {-# LINE 14237 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 117, column 9) _qstarExpansion = {-# LINE 117 "./TypeChecking/TableRefs.ag" #-} [(_alias , _pAttrs )] {-# LINE 14242 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 248, column 9) _lhsOlibUpdates = {-# LINE 248 "./TypeChecking/TableRefs.ag" #-} _libUpdates {-# LINE 14247 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 249, column 9) _lhsOidLookups = {-# LINE 249 "./TypeChecking/TableRefs.ag" #-} _idLookups {-# LINE 14252 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 250, column 9) _lhsOqidLookups = {-# LINE 250 "./TypeChecking/TableRefs.ag" #-} _qidLookups {-# LINE 14257 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 251, column 9) _lhsOstarExpansion = {-# LINE 251 "./TypeChecking/TableRefs.ag" #-} _starExpansion {-# LINE 14262 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 252, column 9) _lhsOqstarExpansion = {-# LINE 252 "./TypeChecking/TableRefs.ag" #-} _qstarExpansion {-# LINE 14267 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 260, column 9) _backTree = {-# LINE 260 "./TypeChecking/TableRefs.ag" #-} Tref ann_ tbl_ _aliasIannotatedTree {-# LINE 14272 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Tref ann_ tbl_ _aliasIannotatedTree {-# LINE 14277 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Tref ann_ tbl_ _aliasIoriginalTree {-# LINE 14282 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 14287 "AstInternal.hs" #-} -- copy rule (down) _aliasOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 14292 "AstInternal.hs" #-} -- copy rule (down) _aliasOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 14297 "AstInternal.hs" #-} ( _aliasIannotatedTree,_aliasIoriginalTree) = (alias_ _aliasOenv _aliasOlib ) in ( _lhsOannotatedTree,_lhsOidLookups,_lhsOlibUpdates,_lhsOoriginalTree,_lhsOqidLookups,_lhsOqstarExpansion,_lhsOstarExpansion))) sem_TableRef_TrefFun :: Annotation -> T_Expression -> T_TableAlias -> T_TableRef sem_TableRef_TrefFun ann_ fn_ alias_ = (\ _lhsIenv _lhsIjlibUpdates _lhsIlib -> (let _lhsOannotatedTree :: TableRef _eqfunIdens :: (Either [TypeError] (String,[(String,Type)])) _idLookups :: ([(String,Type)]) _qidLookups :: ([(String,[(String,Type)])]) _starExpansion :: ([(String,Type)]) _qstarExpansion :: ([(String,[(String,Type)])]) _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _lhsOidLookups :: ([(String,Type)]) _lhsOqidLookups :: ([(String,[(String,Type)])]) _lhsOstarExpansion :: ([(String,Type)]) _lhsOqstarExpansion :: ([(String,[(String,Type)])]) _lhsOoriginalTree :: TableRef _fnOenv :: Environment _fnOlib :: LocalIdentifierBindings _aliasOenv :: Environment _aliasOlib :: LocalIdentifierBindings _fnIannotatedTree :: Expression _fnIliftedColumnName :: String _fnIoriginalTree :: Expression _aliasIannotatedTree :: TableAlias _aliasIoriginalTree :: TableAlias -- "./TypeChecking/TableRefs.ag"(line 33, column 9) _lhsOannotatedTree = {-# LINE 33 "./TypeChecking/TableRefs.ag" #-} updateAnnotation (map TypeErrorA _errs ++) _backTree {-# LINE 14334 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 75, column 9) _libUpdates = {-# LINE 75 "./TypeChecking/TableRefs.ag" #-} if null _errs then [LibStackIDs $ ("", _idLookups ): _qidLookups ,LibSetStarExpansion $ ("", _starExpansion ): _qstarExpansion ] else [] {-# LINE 14342 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 120, column 9) _errs = {-# LINE 120 "./TypeChecking/TableRefs.ag" #-} case _eqfunIdens of Left e -> e Right _ -> [] {-# LINE 14349 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 124, column 9) _eqfunIdens = {-# LINE 124 "./TypeChecking/TableRefs.ag" #-} funIdens _lhsIenv _alias _fnIannotatedTree {-# LINE 14354 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 125, column 9) _qfunIdens = {-# LINE 125 "./TypeChecking/TableRefs.ag" #-} fromRight ("",[]) _eqfunIdens {-# LINE 14359 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 126, column 9) _alias2 = {-# LINE 126 "./TypeChecking/TableRefs.ag" #-} fst _qfunIdens {-# LINE 14364 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 127, column 9) _funIdens = {-# LINE 127 "./TypeChecking/TableRefs.ag" #-} snd _qfunIdens {-# LINE 14369 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 128, column 9) _alias = {-# LINE 128 "./TypeChecking/TableRefs.ag" #-} getAlias "" _aliasIannotatedTree {-# LINE 14374 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 130, column 9) _idLookups = {-# LINE 130 "./TypeChecking/TableRefs.ag" #-} _funIdens {-# LINE 14379 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 131, column 9) _qidLookups = {-# LINE 131 "./TypeChecking/TableRefs.ag" #-} [(_alias2, _idLookups )] {-# LINE 14384 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 132, column 9) _starExpansion = {-# LINE 132 "./TypeChecking/TableRefs.ag" #-} _idLookups {-# LINE 14389 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 133, column 9) _qstarExpansion = {-# LINE 133 "./TypeChecking/TableRefs.ag" #-} _qidLookups {-# LINE 14394 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 248, column 9) _lhsOlibUpdates = {-# LINE 248 "./TypeChecking/TableRefs.ag" #-} _libUpdates {-# LINE 14399 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 249, column 9) _lhsOidLookups = {-# LINE 249 "./TypeChecking/TableRefs.ag" #-} _idLookups {-# LINE 14404 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 250, column 9) _lhsOqidLookups = {-# LINE 250 "./TypeChecking/TableRefs.ag" #-} _qidLookups {-# LINE 14409 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 251, column 9) _lhsOstarExpansion = {-# LINE 251 "./TypeChecking/TableRefs.ag" #-} _starExpansion {-# LINE 14414 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 252, column 9) _lhsOqstarExpansion = {-# LINE 252 "./TypeChecking/TableRefs.ag" #-} _qstarExpansion {-# LINE 14419 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 262, column 9) _backTree = {-# LINE 262 "./TypeChecking/TableRefs.ag" #-} TrefFun ann_ _fnIannotatedTree _aliasIannotatedTree {-# LINE 14424 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} TrefFun ann_ _fnIannotatedTree _aliasIannotatedTree {-# LINE 14429 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} TrefFun ann_ _fnIoriginalTree _aliasIoriginalTree {-# LINE 14434 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 14439 "AstInternal.hs" #-} -- copy rule (down) _fnOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 14444 "AstInternal.hs" #-} -- copy rule (down) _fnOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 14449 "AstInternal.hs" #-} -- copy rule (down) _aliasOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 14454 "AstInternal.hs" #-} -- copy rule (down) _aliasOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 14459 "AstInternal.hs" #-} ( _fnIannotatedTree,_fnIliftedColumnName,_fnIoriginalTree) = (fn_ _fnOenv _fnOlib ) ( _aliasIannotatedTree,_aliasIoriginalTree) = (alias_ _aliasOenv _aliasOlib ) in ( _lhsOannotatedTree,_lhsOidLookups,_lhsOlibUpdates,_lhsOoriginalTree,_lhsOqidLookups,_lhsOqstarExpansion,_lhsOstarExpansion))) -- TableRefList ------------------------------------------------ {- visit 0: inherited attributes: env : Environment lib : LocalIdentifierBindings synthesized attributes: annotatedTree : SELF libUpdates : [LocalIdentifierBindingsUpdate] originalTree : SELF alternatives: alternative Cons: child hd : TableRef child tl : TableRefList visit 0: local annotatedTree : _ local originalTree : _ alternative Nil: visit 0: local annotatedTree : _ local originalTree : _ -} type TableRefList = [(TableRef)] -- cata sem_TableRefList :: TableRefList -> T_TableRefList sem_TableRefList list = (Prelude.foldr sem_TableRefList_Cons sem_TableRefList_Nil (Prelude.map sem_TableRef list) ) -- semantic domain type T_TableRefList = Environment -> LocalIdentifierBindings -> ( TableRefList,([LocalIdentifierBindingsUpdate]),TableRefList) data Inh_TableRefList = Inh_TableRefList {env_Inh_TableRefList :: Environment,lib_Inh_TableRefList :: LocalIdentifierBindings} data Syn_TableRefList = Syn_TableRefList {annotatedTree_Syn_TableRefList :: TableRefList,libUpdates_Syn_TableRefList :: [LocalIdentifierBindingsUpdate],originalTree_Syn_TableRefList :: TableRefList} wrap_TableRefList :: T_TableRefList -> Inh_TableRefList -> Syn_TableRefList wrap_TableRefList sem (Inh_TableRefList _lhsIenv _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOlibUpdates,_lhsOoriginalTree) = (sem _lhsIenv _lhsIlib ) in (Syn_TableRefList _lhsOannotatedTree _lhsOlibUpdates _lhsOoriginalTree )) sem_TableRefList_Cons :: T_TableRef -> T_TableRefList -> T_TableRefList sem_TableRefList_Cons hd_ tl_ = (\ _lhsIenv _lhsIlib -> (let _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _hdOjlibUpdates :: ([LocalIdentifierBindingsUpdate]) _lhsOannotatedTree :: TableRefList _lhsOoriginalTree :: TableRefList _hdOenv :: Environment _hdOlib :: LocalIdentifierBindings _tlOenv :: Environment _tlOlib :: LocalIdentifierBindings _hdIannotatedTree :: TableRef _hdIidLookups :: ([(String,Type)]) _hdIlibUpdates :: ([LocalIdentifierBindingsUpdate]) _hdIoriginalTree :: TableRef _hdIqidLookups :: ([(String,[(String,Type)])]) _hdIqstarExpansion :: ([(String,[(String,Type)])]) _hdIstarExpansion :: ([(String,Type)]) _tlIannotatedTree :: TableRefList _tlIlibUpdates :: ([LocalIdentifierBindingsUpdate]) _tlIoriginalTree :: TableRefList -- "./TypeChecking/TableRefs.ag"(line 40, column 9) _lhsOlibUpdates = {-# LINE 40 "./TypeChecking/TableRefs.ag" #-} _hdIlibUpdates {-# LINE 14534 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 197, column 12) _hdOjlibUpdates = {-# LINE 197 "./TypeChecking/TableRefs.ag" #-} [] {-# LINE 14539 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} (:) _hdIannotatedTree _tlIannotatedTree {-# LINE 14544 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} (:) _hdIoriginalTree _tlIoriginalTree {-# LINE 14549 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 14554 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 14559 "AstInternal.hs" #-} -- copy rule (down) _hdOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 14564 "AstInternal.hs" #-} -- copy rule (down) _hdOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 14569 "AstInternal.hs" #-} -- copy rule (down) _tlOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 14574 "AstInternal.hs" #-} -- copy rule (down) _tlOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 14579 "AstInternal.hs" #-} ( _hdIannotatedTree,_hdIidLookups,_hdIlibUpdates,_hdIoriginalTree,_hdIqidLookups,_hdIqstarExpansion,_hdIstarExpansion) = (hd_ _hdOenv _hdOjlibUpdates _hdOlib ) ( _tlIannotatedTree,_tlIlibUpdates,_tlIoriginalTree) = (tl_ _tlOenv _tlOlib ) in ( _lhsOannotatedTree,_lhsOlibUpdates,_lhsOoriginalTree))) sem_TableRefList_Nil :: T_TableRefList sem_TableRefList_Nil = (\ _lhsIenv _lhsIlib -> (let _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _lhsOannotatedTree :: TableRefList _lhsOoriginalTree :: TableRefList -- "./TypeChecking/TableRefs.ag"(line 38, column 9) _lhsOlibUpdates = {-# LINE 38 "./TypeChecking/TableRefs.ag" #-} [] {-# LINE 14596 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 14601 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 14606 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 14611 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 14616 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOlibUpdates,_lhsOoriginalTree))) -- TriggerEvent ------------------------------------------------ {- visit 0: inherited attributes: env : Environment lib : LocalIdentifierBindings synthesized attributes: annotatedTree : SELF originalTree : SELF alternatives: alternative TDelete: visit 0: local annotatedTree : _ local originalTree : _ alternative TInsert: visit 0: local annotatedTree : _ local originalTree : _ alternative TUpdate: visit 0: local annotatedTree : _ local originalTree : _ -} data TriggerEvent = TDelete | TInsert | TUpdate deriving ( Data,Eq,Show,Typeable) -- cata sem_TriggerEvent :: TriggerEvent -> T_TriggerEvent sem_TriggerEvent (TDelete ) = (sem_TriggerEvent_TDelete ) sem_TriggerEvent (TInsert ) = (sem_TriggerEvent_TInsert ) sem_TriggerEvent (TUpdate ) = (sem_TriggerEvent_TUpdate ) -- semantic domain type T_TriggerEvent = Environment -> LocalIdentifierBindings -> ( TriggerEvent,TriggerEvent) data Inh_TriggerEvent = Inh_TriggerEvent {env_Inh_TriggerEvent :: Environment,lib_Inh_TriggerEvent :: LocalIdentifierBindings} data Syn_TriggerEvent = Syn_TriggerEvent {annotatedTree_Syn_TriggerEvent :: TriggerEvent,originalTree_Syn_TriggerEvent :: TriggerEvent} wrap_TriggerEvent :: T_TriggerEvent -> Inh_TriggerEvent -> Syn_TriggerEvent wrap_TriggerEvent sem (Inh_TriggerEvent _lhsIenv _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIenv _lhsIlib ) in (Syn_TriggerEvent _lhsOannotatedTree _lhsOoriginalTree )) sem_TriggerEvent_TDelete :: T_TriggerEvent sem_TriggerEvent_TDelete = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: TriggerEvent _lhsOoriginalTree :: TriggerEvent -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} TDelete {-# LINE 14677 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} TDelete {-# LINE 14682 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 14687 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 14692 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_TriggerEvent_TInsert :: T_TriggerEvent sem_TriggerEvent_TInsert = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: TriggerEvent _lhsOoriginalTree :: TriggerEvent -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} TInsert {-# LINE 14704 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} TInsert {-# LINE 14709 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 14714 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 14719 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_TriggerEvent_TUpdate :: T_TriggerEvent sem_TriggerEvent_TUpdate = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: TriggerEvent _lhsOoriginalTree :: TriggerEvent -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} TUpdate {-# LINE 14731 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} TUpdate {-# LINE 14736 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 14741 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 14746 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) -- TriggerFire ------------------------------------------------- {- visit 0: inherited attributes: env : Environment lib : LocalIdentifierBindings synthesized attributes: annotatedTree : SELF originalTree : SELF alternatives: alternative EachRow: visit 0: local annotatedTree : _ local originalTree : _ alternative EachStatement: visit 0: local annotatedTree : _ local originalTree : _ -} data TriggerFire = EachRow | EachStatement deriving ( Data,Eq,Show,Typeable) -- cata sem_TriggerFire :: TriggerFire -> T_TriggerFire sem_TriggerFire (EachRow ) = (sem_TriggerFire_EachRow ) sem_TriggerFire (EachStatement ) = (sem_TriggerFire_EachStatement ) -- semantic domain type T_TriggerFire = Environment -> LocalIdentifierBindings -> ( TriggerFire,TriggerFire) data Inh_TriggerFire = Inh_TriggerFire {env_Inh_TriggerFire :: Environment,lib_Inh_TriggerFire :: LocalIdentifierBindings} data Syn_TriggerFire = Syn_TriggerFire {annotatedTree_Syn_TriggerFire :: TriggerFire,originalTree_Syn_TriggerFire :: TriggerFire} wrap_TriggerFire :: T_TriggerFire -> Inh_TriggerFire -> Syn_TriggerFire wrap_TriggerFire sem (Inh_TriggerFire _lhsIenv _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIenv _lhsIlib ) in (Syn_TriggerFire _lhsOannotatedTree _lhsOoriginalTree )) sem_TriggerFire_EachRow :: T_TriggerFire sem_TriggerFire_EachRow = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: TriggerFire _lhsOoriginalTree :: TriggerFire -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} EachRow {-# LINE 14800 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} EachRow {-# LINE 14805 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 14810 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 14815 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_TriggerFire_EachStatement :: T_TriggerFire sem_TriggerFire_EachStatement = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: TriggerFire _lhsOoriginalTree :: TriggerFire -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} EachStatement {-# LINE 14827 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} EachStatement {-# LINE 14832 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 14837 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 14842 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) -- TriggerWhen ------------------------------------------------- {- visit 0: inherited attributes: env : Environment lib : LocalIdentifierBindings synthesized attributes: annotatedTree : SELF originalTree : SELF alternatives: alternative TriggerAfter: visit 0: local annotatedTree : _ local originalTree : _ alternative TriggerBefore: visit 0: local annotatedTree : _ local originalTree : _ -} data TriggerWhen = TriggerAfter | TriggerBefore deriving ( Data,Eq,Show,Typeable) -- cata sem_TriggerWhen :: TriggerWhen -> T_TriggerWhen sem_TriggerWhen (TriggerAfter ) = (sem_TriggerWhen_TriggerAfter ) sem_TriggerWhen (TriggerBefore ) = (sem_TriggerWhen_TriggerBefore ) -- semantic domain type T_TriggerWhen = Environment -> LocalIdentifierBindings -> ( TriggerWhen,TriggerWhen) data Inh_TriggerWhen = Inh_TriggerWhen {env_Inh_TriggerWhen :: Environment,lib_Inh_TriggerWhen :: LocalIdentifierBindings} data Syn_TriggerWhen = Syn_TriggerWhen {annotatedTree_Syn_TriggerWhen :: TriggerWhen,originalTree_Syn_TriggerWhen :: TriggerWhen} wrap_TriggerWhen :: T_TriggerWhen -> Inh_TriggerWhen -> Syn_TriggerWhen wrap_TriggerWhen sem (Inh_TriggerWhen _lhsIenv _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIenv _lhsIlib ) in (Syn_TriggerWhen _lhsOannotatedTree _lhsOoriginalTree )) sem_TriggerWhen_TriggerAfter :: T_TriggerWhen sem_TriggerWhen_TriggerAfter = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: TriggerWhen _lhsOoriginalTree :: TriggerWhen -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} TriggerAfter {-# LINE 14896 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} TriggerAfter {-# LINE 14901 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 14906 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 14911 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_TriggerWhen_TriggerBefore :: T_TriggerWhen sem_TriggerWhen_TriggerBefore = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: TriggerWhen _lhsOoriginalTree :: TriggerWhen -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} TriggerBefore {-# LINE 14923 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} TriggerBefore {-# LINE 14928 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 14933 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 14938 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) -- TypeAttributeDef -------------------------------------------- {- visit 0: inherited attributes: env : Environment lib : LocalIdentifierBindings synthesized attributes: annotatedTree : SELF attrName : String namedType : Type originalTree : SELF alternatives: alternative TypeAttDef: child ann : {Annotation} child name : {String} child typ : TypeName visit 0: local annotatedTree : _ local originalTree : _ -} data TypeAttributeDef = TypeAttDef (Annotation) (String) (TypeName) deriving ( Data,Eq,Show,Typeable) -- cata sem_TypeAttributeDef :: TypeAttributeDef -> T_TypeAttributeDef sem_TypeAttributeDef (TypeAttDef _ann _name _typ ) = (sem_TypeAttributeDef_TypeAttDef _ann _name (sem_TypeName _typ ) ) -- semantic domain type T_TypeAttributeDef = Environment -> LocalIdentifierBindings -> ( TypeAttributeDef,String,Type,TypeAttributeDef) data Inh_TypeAttributeDef = Inh_TypeAttributeDef {env_Inh_TypeAttributeDef :: Environment,lib_Inh_TypeAttributeDef :: LocalIdentifierBindings} data Syn_TypeAttributeDef = Syn_TypeAttributeDef {annotatedTree_Syn_TypeAttributeDef :: TypeAttributeDef,attrName_Syn_TypeAttributeDef :: String,namedType_Syn_TypeAttributeDef :: Type,originalTree_Syn_TypeAttributeDef :: TypeAttributeDef} wrap_TypeAttributeDef :: T_TypeAttributeDef -> Inh_TypeAttributeDef -> Syn_TypeAttributeDef wrap_TypeAttributeDef sem (Inh_TypeAttributeDef _lhsIenv _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOattrName,_lhsOnamedType,_lhsOoriginalTree) = (sem _lhsIenv _lhsIlib ) in (Syn_TypeAttributeDef _lhsOannotatedTree _lhsOattrName _lhsOnamedType _lhsOoriginalTree )) sem_TypeAttributeDef_TypeAttDef :: Annotation -> String -> T_TypeName -> T_TypeAttributeDef sem_TypeAttributeDef_TypeAttDef ann_ name_ typ_ = (\ _lhsIenv _lhsIlib -> (let _lhsOattrName :: String _lhsOnamedType :: Type _lhsOannotatedTree :: TypeAttributeDef _lhsOoriginalTree :: TypeAttributeDef _typOenv :: Environment _typOlib :: LocalIdentifierBindings _typIannotatedTree :: TypeName _typInamedType :: Type _typIoriginalTree :: TypeName -- "./TypeChecking/MiscCreates.ag"(line 40, column 9) _lhsOattrName = {-# LINE 40 "./TypeChecking/MiscCreates.ag" #-} name_ {-# LINE 15000 "AstInternal.hs" #-} -- "./TypeChecking/MiscCreates.ag"(line 41, column 9) _lhsOnamedType = {-# LINE 41 "./TypeChecking/MiscCreates.ag" #-} _typInamedType {-# LINE 15005 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} TypeAttDef ann_ name_ _typIannotatedTree {-# LINE 15010 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} TypeAttDef ann_ name_ _typIoriginalTree {-# LINE 15015 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 15020 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 15025 "AstInternal.hs" #-} -- copy rule (down) _typOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 15030 "AstInternal.hs" #-} -- copy rule (down) _typOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 15035 "AstInternal.hs" #-} ( _typIannotatedTree,_typInamedType,_typIoriginalTree) = (typ_ _typOenv _typOlib ) in ( _lhsOannotatedTree,_lhsOattrName,_lhsOnamedType,_lhsOoriginalTree))) -- TypeAttributeDefList ---------------------------------------- {- visit 0: inherited attributes: env : Environment lib : LocalIdentifierBindings synthesized attributes: annotatedTree : SELF attrs : [(String, Type)] originalTree : SELF alternatives: alternative Cons: child hd : TypeAttributeDef child tl : TypeAttributeDefList visit 0: local annotatedTree : _ local originalTree : _ alternative Nil: visit 0: local annotatedTree : _ local originalTree : _ -} type TypeAttributeDefList = [(TypeAttributeDef)] -- cata sem_TypeAttributeDefList :: TypeAttributeDefList -> T_TypeAttributeDefList sem_TypeAttributeDefList list = (Prelude.foldr sem_TypeAttributeDefList_Cons sem_TypeAttributeDefList_Nil (Prelude.map sem_TypeAttributeDef list) ) -- semantic domain type T_TypeAttributeDefList = Environment -> LocalIdentifierBindings -> ( TypeAttributeDefList,([(String, Type)]),TypeAttributeDefList) data Inh_TypeAttributeDefList = Inh_TypeAttributeDefList {env_Inh_TypeAttributeDefList :: Environment,lib_Inh_TypeAttributeDefList :: LocalIdentifierBindings} data Syn_TypeAttributeDefList = Syn_TypeAttributeDefList {annotatedTree_Syn_TypeAttributeDefList :: TypeAttributeDefList,attrs_Syn_TypeAttributeDefList :: [(String, Type)],originalTree_Syn_TypeAttributeDefList :: TypeAttributeDefList} wrap_TypeAttributeDefList :: T_TypeAttributeDefList -> Inh_TypeAttributeDefList -> Syn_TypeAttributeDefList wrap_TypeAttributeDefList sem (Inh_TypeAttributeDefList _lhsIenv _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOattrs,_lhsOoriginalTree) = (sem _lhsIenv _lhsIlib ) in (Syn_TypeAttributeDefList _lhsOannotatedTree _lhsOattrs _lhsOoriginalTree )) sem_TypeAttributeDefList_Cons :: T_TypeAttributeDef -> T_TypeAttributeDefList -> T_TypeAttributeDefList sem_TypeAttributeDefList_Cons hd_ tl_ = (\ _lhsIenv _lhsIlib -> (let _lhsOattrs :: ([(String, Type)]) _lhsOannotatedTree :: TypeAttributeDefList _lhsOoriginalTree :: TypeAttributeDefList _hdOenv :: Environment _hdOlib :: LocalIdentifierBindings _tlOenv :: Environment _tlOlib :: LocalIdentifierBindings _hdIannotatedTree :: TypeAttributeDef _hdIattrName :: String _hdInamedType :: Type _hdIoriginalTree :: TypeAttributeDef _tlIannotatedTree :: TypeAttributeDefList _tlIattrs :: ([(String, Type)]) _tlIoriginalTree :: TypeAttributeDefList -- "./TypeChecking/MiscCreates.ag"(line 46, column 12) _lhsOattrs = {-# LINE 46 "./TypeChecking/MiscCreates.ag" #-} (_hdIattrName, _hdInamedType) : _tlIattrs {-# LINE 15104 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} (:) _hdIannotatedTree _tlIannotatedTree {-# LINE 15109 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} (:) _hdIoriginalTree _tlIoriginalTree {-# LINE 15114 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 15119 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 15124 "AstInternal.hs" #-} -- copy rule (down) _hdOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 15129 "AstInternal.hs" #-} -- copy rule (down) _hdOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 15134 "AstInternal.hs" #-} -- copy rule (down) _tlOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 15139 "AstInternal.hs" #-} -- copy rule (down) _tlOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 15144 "AstInternal.hs" #-} ( _hdIannotatedTree,_hdIattrName,_hdInamedType,_hdIoriginalTree) = (hd_ _hdOenv _hdOlib ) ( _tlIannotatedTree,_tlIattrs,_tlIoriginalTree) = (tl_ _tlOenv _tlOlib ) in ( _lhsOannotatedTree,_lhsOattrs,_lhsOoriginalTree))) sem_TypeAttributeDefList_Nil :: T_TypeAttributeDefList sem_TypeAttributeDefList_Nil = (\ _lhsIenv _lhsIlib -> (let _lhsOattrs :: ([(String, Type)]) _lhsOannotatedTree :: TypeAttributeDefList _lhsOoriginalTree :: TypeAttributeDefList -- "./TypeChecking/MiscCreates.ag"(line 47, column 11) _lhsOattrs = {-# LINE 47 "./TypeChecking/MiscCreates.ag" #-} [] {-# LINE 15161 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 15166 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 15171 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 15176 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 15181 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOattrs,_lhsOoriginalTree))) -- TypeName ---------------------------------------------------- {- visit 0: inherited attributes: env : Environment lib : LocalIdentifierBindings synthesized attributes: annotatedTree : SELF namedType : Type originalTree : SELF alternatives: alternative ArrayTypeName: child ann : {Annotation} child typ : TypeName visit 0: local tpe : _ local backTree : _ local annotatedTree : _ local originalTree : _ alternative PrecTypeName: child ann : {Annotation} child tn : {String} child prec : {Integer} visit 0: local tpe : _ local backTree : _ local annotatedTree : _ local originalTree : _ alternative SetOfTypeName: child ann : {Annotation} child typ : TypeName visit 0: local tpe : _ local backTree : _ local annotatedTree : _ local originalTree : _ alternative SimpleTypeName: child ann : {Annotation} child tn : {String} visit 0: local tpe : _ local backTree : _ local annotatedTree : _ local originalTree : _ -} data TypeName = ArrayTypeName (Annotation) (TypeName) | PrecTypeName (Annotation) (String) (Integer) | SetOfTypeName (Annotation) (TypeName) | SimpleTypeName (Annotation) (String) deriving ( Data,Eq,Show,Typeable) -- cata sem_TypeName :: TypeName -> T_TypeName sem_TypeName (ArrayTypeName _ann _typ ) = (sem_TypeName_ArrayTypeName _ann (sem_TypeName _typ ) ) sem_TypeName (PrecTypeName _ann _tn _prec ) = (sem_TypeName_PrecTypeName _ann _tn _prec ) sem_TypeName (SetOfTypeName _ann _typ ) = (sem_TypeName_SetOfTypeName _ann (sem_TypeName _typ ) ) sem_TypeName (SimpleTypeName _ann _tn ) = (sem_TypeName_SimpleTypeName _ann _tn ) -- semantic domain type T_TypeName = Environment -> LocalIdentifierBindings -> ( TypeName,Type,TypeName) data Inh_TypeName = Inh_TypeName {env_Inh_TypeName :: Environment,lib_Inh_TypeName :: LocalIdentifierBindings} data Syn_TypeName = Syn_TypeName {annotatedTree_Syn_TypeName :: TypeName,namedType_Syn_TypeName :: Type,originalTree_Syn_TypeName :: TypeName} wrap_TypeName :: T_TypeName -> Inh_TypeName -> Syn_TypeName wrap_TypeName sem (Inh_TypeName _lhsIenv _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOnamedType,_lhsOoriginalTree) = (sem _lhsIenv _lhsIlib ) in (Syn_TypeName _lhsOannotatedTree _lhsOnamedType _lhsOoriginalTree )) sem_TypeName_ArrayTypeName :: Annotation -> T_TypeName -> T_TypeName sem_TypeName_ArrayTypeName ann_ typ_ = (\ _lhsIenv _lhsIlib -> (let _lhsOnamedType :: Type _lhsOannotatedTree :: TypeName _lhsOoriginalTree :: TypeName _typOenv :: Environment _typOlib :: LocalIdentifierBindings _typIannotatedTree :: TypeName _typInamedType :: Type _typIoriginalTree :: TypeName -- "./TypeChecking/Misc.ag"(line 19, column 10) _lhsOnamedType = {-# LINE 19 "./TypeChecking/Misc.ag" #-} tpeToT _tpe {-# LINE 15275 "AstInternal.hs" #-} -- "./TypeChecking/Misc.ag"(line 20, column 10) _lhsOannotatedTree = {-# LINE 20 "./TypeChecking/Misc.ag" #-} updateAnnotation ((map TypeErrorA $ getErrors _tpe ) ++) _backTree {-# LINE 15282 "AstInternal.hs" #-} -- "./TypeChecking/Misc.ag"(line 30, column 9) _tpe = {-# LINE 30 "./TypeChecking/Misc.ag" #-} dependsOnRTpe [_typInamedType] $ Right $ ArrayType _typInamedType {-# LINE 15287 "AstInternal.hs" #-} -- "./TypeChecking/Misc.ag"(line 31, column 9) _backTree = {-# LINE 31 "./TypeChecking/Misc.ag" #-} ArrayTypeName ann_ _typIannotatedTree {-# LINE 15292 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} ArrayTypeName ann_ _typIannotatedTree {-# LINE 15297 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} ArrayTypeName ann_ _typIoriginalTree {-# LINE 15302 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 15307 "AstInternal.hs" #-} -- copy rule (down) _typOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 15312 "AstInternal.hs" #-} -- copy rule (down) _typOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 15317 "AstInternal.hs" #-} ( _typIannotatedTree,_typInamedType,_typIoriginalTree) = (typ_ _typOenv _typOlib ) in ( _lhsOannotatedTree,_lhsOnamedType,_lhsOoriginalTree))) sem_TypeName_PrecTypeName :: Annotation -> String -> Integer -> T_TypeName sem_TypeName_PrecTypeName ann_ tn_ prec_ = (\ _lhsIenv _lhsIlib -> (let _lhsOnamedType :: Type _lhsOannotatedTree :: TypeName _lhsOoriginalTree :: TypeName -- "./TypeChecking/Misc.ag"(line 19, column 10) _lhsOnamedType = {-# LINE 19 "./TypeChecking/Misc.ag" #-} tpeToT _tpe {-# LINE 15335 "AstInternal.hs" #-} -- "./TypeChecking/Misc.ag"(line 20, column 10) _lhsOannotatedTree = {-# LINE 20 "./TypeChecking/Misc.ag" #-} updateAnnotation ((map TypeErrorA $ getErrors _tpe ) ++) _backTree {-# LINE 15342 "AstInternal.hs" #-} -- "./TypeChecking/Misc.ag"(line 36, column 9) _tpe = {-# LINE 36 "./TypeChecking/Misc.ag" #-} envLookupType _lhsIenv $ canonicalizeTypeName tn_ {-# LINE 15347 "AstInternal.hs" #-} -- "./TypeChecking/Misc.ag"(line 37, column 9) _backTree = {-# LINE 37 "./TypeChecking/Misc.ag" #-} PrecTypeName ann_ tn_ prec_ {-# LINE 15352 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} PrecTypeName ann_ tn_ prec_ {-# LINE 15357 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} PrecTypeName ann_ tn_ prec_ {-# LINE 15362 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 15367 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOnamedType,_lhsOoriginalTree))) sem_TypeName_SetOfTypeName :: Annotation -> T_TypeName -> T_TypeName sem_TypeName_SetOfTypeName ann_ typ_ = (\ _lhsIenv _lhsIlib -> (let _lhsOnamedType :: Type _lhsOannotatedTree :: TypeName _lhsOoriginalTree :: TypeName _typOenv :: Environment _typOlib :: LocalIdentifierBindings _typIannotatedTree :: TypeName _typInamedType :: Type _typIoriginalTree :: TypeName -- "./TypeChecking/Misc.ag"(line 19, column 10) _lhsOnamedType = {-# LINE 19 "./TypeChecking/Misc.ag" #-} tpeToT _tpe {-# LINE 15387 "AstInternal.hs" #-} -- "./TypeChecking/Misc.ag"(line 20, column 10) _lhsOannotatedTree = {-# LINE 20 "./TypeChecking/Misc.ag" #-} updateAnnotation ((map TypeErrorA $ getErrors _tpe ) ++) _backTree {-# LINE 15394 "AstInternal.hs" #-} -- "./TypeChecking/Misc.ag"(line 33, column 9) _tpe = {-# LINE 33 "./TypeChecking/Misc.ag" #-} dependsOnRTpe [_typInamedType] $ Right $ SetOfType _typInamedType {-# LINE 15399 "AstInternal.hs" #-} -- "./TypeChecking/Misc.ag"(line 34, column 9) _backTree = {-# LINE 34 "./TypeChecking/Misc.ag" #-} SetOfTypeName ann_ _typIannotatedTree {-# LINE 15404 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} SetOfTypeName ann_ _typIannotatedTree {-# LINE 15409 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} SetOfTypeName ann_ _typIoriginalTree {-# LINE 15414 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 15419 "AstInternal.hs" #-} -- copy rule (down) _typOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 15424 "AstInternal.hs" #-} -- copy rule (down) _typOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 15429 "AstInternal.hs" #-} ( _typIannotatedTree,_typInamedType,_typIoriginalTree) = (typ_ _typOenv _typOlib ) in ( _lhsOannotatedTree,_lhsOnamedType,_lhsOoriginalTree))) sem_TypeName_SimpleTypeName :: Annotation -> String -> T_TypeName sem_TypeName_SimpleTypeName ann_ tn_ = (\ _lhsIenv _lhsIlib -> (let _lhsOnamedType :: Type _lhsOannotatedTree :: TypeName _lhsOoriginalTree :: TypeName -- "./TypeChecking/Misc.ag"(line 19, column 10) _lhsOnamedType = {-# LINE 19 "./TypeChecking/Misc.ag" #-} tpeToT _tpe {-# LINE 15446 "AstInternal.hs" #-} -- "./TypeChecking/Misc.ag"(line 20, column 10) _lhsOannotatedTree = {-# LINE 20 "./TypeChecking/Misc.ag" #-} updateAnnotation ((map TypeErrorA $ getErrors _tpe ) ++) _backTree {-# LINE 15453 "AstInternal.hs" #-} -- "./TypeChecking/Misc.ag"(line 27, column 9) _tpe = {-# LINE 27 "./TypeChecking/Misc.ag" #-} envLookupType _lhsIenv $ canonicalizeTypeName tn_ {-# LINE 15458 "AstInternal.hs" #-} -- "./TypeChecking/Misc.ag"(line 28, column 9) _backTree = {-# LINE 28 "./TypeChecking/Misc.ag" #-} SimpleTypeName ann_ tn_ {-# LINE 15463 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} SimpleTypeName ann_ tn_ {-# LINE 15468 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} SimpleTypeName ann_ tn_ {-# LINE 15473 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 15478 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOnamedType,_lhsOoriginalTree))) -- TypeNameList ------------------------------------------------ {- visit 0: inherited attributes: env : Environment lib : LocalIdentifierBindings synthesized attributes: annotatedTree : SELF namedTypes : [Type] originalTree : SELF alternatives: alternative Cons: child hd : TypeName child tl : TypeNameList visit 0: local annotatedTree : _ local originalTree : _ alternative Nil: visit 0: local annotatedTree : _ local originalTree : _ -} type TypeNameList = [(TypeName)] -- cata sem_TypeNameList :: TypeNameList -> T_TypeNameList sem_TypeNameList list = (Prelude.foldr sem_TypeNameList_Cons sem_TypeNameList_Nil (Prelude.map sem_TypeName list) ) -- semantic domain type T_TypeNameList = Environment -> LocalIdentifierBindings -> ( TypeNameList,([Type]),TypeNameList) data Inh_TypeNameList = Inh_TypeNameList {env_Inh_TypeNameList :: Environment,lib_Inh_TypeNameList :: LocalIdentifierBindings} data Syn_TypeNameList = Syn_TypeNameList {annotatedTree_Syn_TypeNameList :: TypeNameList,namedTypes_Syn_TypeNameList :: [Type],originalTree_Syn_TypeNameList :: TypeNameList} wrap_TypeNameList :: T_TypeNameList -> Inh_TypeNameList -> Syn_TypeNameList wrap_TypeNameList sem (Inh_TypeNameList _lhsIenv _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOnamedTypes,_lhsOoriginalTree) = (sem _lhsIenv _lhsIlib ) in (Syn_TypeNameList _lhsOannotatedTree _lhsOnamedTypes _lhsOoriginalTree )) sem_TypeNameList_Cons :: T_TypeName -> T_TypeNameList -> T_TypeNameList sem_TypeNameList_Cons hd_ tl_ = (\ _lhsIenv _lhsIlib -> (let _lhsOnamedTypes :: ([Type]) _lhsOannotatedTree :: TypeNameList _lhsOoriginalTree :: TypeNameList _hdOenv :: Environment _hdOlib :: LocalIdentifierBindings _tlOenv :: Environment _tlOlib :: LocalIdentifierBindings _hdIannotatedTree :: TypeName _hdInamedType :: Type _hdIoriginalTree :: TypeName _tlIannotatedTree :: TypeNameList _tlInamedTypes :: ([Type]) _tlIoriginalTree :: TypeNameList -- "./TypeChecking/Drops.ag"(line 30, column 12) _lhsOnamedTypes = {-# LINE 30 "./TypeChecking/Drops.ag" #-} _hdInamedType : _tlInamedTypes {-# LINE 15544 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} (:) _hdIannotatedTree _tlIannotatedTree {-# LINE 15549 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} (:) _hdIoriginalTree _tlIoriginalTree {-# LINE 15554 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 15559 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 15564 "AstInternal.hs" #-} -- copy rule (down) _hdOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 15569 "AstInternal.hs" #-} -- copy rule (down) _hdOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 15574 "AstInternal.hs" #-} -- copy rule (down) _tlOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 15579 "AstInternal.hs" #-} -- copy rule (down) _tlOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 15584 "AstInternal.hs" #-} ( _hdIannotatedTree,_hdInamedType,_hdIoriginalTree) = (hd_ _hdOenv _hdOlib ) ( _tlIannotatedTree,_tlInamedTypes,_tlIoriginalTree) = (tl_ _tlOenv _tlOlib ) in ( _lhsOannotatedTree,_lhsOnamedTypes,_lhsOoriginalTree))) sem_TypeNameList_Nil :: T_TypeNameList sem_TypeNameList_Nil = (\ _lhsIenv _lhsIlib -> (let _lhsOnamedTypes :: ([Type]) _lhsOannotatedTree :: TypeNameList _lhsOoriginalTree :: TypeNameList -- "./TypeChecking/Drops.ag"(line 31, column 11) _lhsOnamedTypes = {-# LINE 31 "./TypeChecking/Drops.ag" #-} [] {-# LINE 15601 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 15606 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 15611 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 15616 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 15621 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOnamedTypes,_lhsOoriginalTree))) -- VarDef ------------------------------------------------------ {- visit 0: inherited attributes: env : Environment lib : LocalIdentifierBindings synthesized attributes: annotatedTree : SELF def : (String,Type) originalTree : SELF alternatives: alternative VarDef: child ann : {Annotation} child name : {String} child typ : TypeName child value : {Maybe Expression} visit 0: local annotatedTree : _ local originalTree : _ -} data VarDef = VarDef (Annotation) (String) (TypeName) (Maybe Expression) deriving ( Data,Eq,Show,Typeable) -- cata sem_VarDef :: VarDef -> T_VarDef sem_VarDef (VarDef _ann _name _typ _value ) = (sem_VarDef_VarDef _ann _name (sem_TypeName _typ ) _value ) -- semantic domain type T_VarDef = Environment -> LocalIdentifierBindings -> ( VarDef,((String,Type)),VarDef) data Inh_VarDef = Inh_VarDef {env_Inh_VarDef :: Environment,lib_Inh_VarDef :: LocalIdentifierBindings} data Syn_VarDef = Syn_VarDef {annotatedTree_Syn_VarDef :: VarDef,def_Syn_VarDef :: (String,Type),originalTree_Syn_VarDef :: VarDef} wrap_VarDef :: T_VarDef -> Inh_VarDef -> Syn_VarDef wrap_VarDef sem (Inh_VarDef _lhsIenv _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOdef,_lhsOoriginalTree) = (sem _lhsIenv _lhsIlib ) in (Syn_VarDef _lhsOannotatedTree _lhsOdef _lhsOoriginalTree )) sem_VarDef_VarDef :: Annotation -> String -> T_TypeName -> (Maybe Expression) -> T_VarDef sem_VarDef_VarDef ann_ name_ typ_ value_ = (\ _lhsIenv _lhsIlib -> (let _lhsOdef :: ((String,Type)) _lhsOannotatedTree :: VarDef _lhsOoriginalTree :: VarDef _typOenv :: Environment _typOlib :: LocalIdentifierBindings _typIannotatedTree :: TypeName _typInamedType :: Type _typIoriginalTree :: TypeName -- "./TypeChecking/CreateFunction.ag"(line 131, column 14) _lhsOdef = {-# LINE 131 "./TypeChecking/CreateFunction.ag" #-} (name_, if _typInamedType == Pseudo Record then PgRecord Nothing else _typInamedType) {-# LINE 15683 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} VarDef ann_ name_ _typIannotatedTree value_ {-# LINE 15688 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} VarDef ann_ name_ _typIoriginalTree value_ {-# LINE 15693 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 15698 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 15703 "AstInternal.hs" #-} -- copy rule (down) _typOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 15708 "AstInternal.hs" #-} -- copy rule (down) _typOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 15713 "AstInternal.hs" #-} ( _typIannotatedTree,_typInamedType,_typIoriginalTree) = (typ_ _typOenv _typOlib ) in ( _lhsOannotatedTree,_lhsOdef,_lhsOoriginalTree))) -- VarDefList -------------------------------------------------- {- visit 0: inherited attributes: env : Environment lib : LocalIdentifierBindings synthesized attributes: annotatedTree : SELF defs : [(String,Type)] originalTree : SELF alternatives: alternative Cons: child hd : VarDef child tl : VarDefList visit 0: local annotatedTree : _ local originalTree : _ alternative Nil: visit 0: local annotatedTree : _ local originalTree : _ -} type VarDefList = [(VarDef)] -- cata sem_VarDefList :: VarDefList -> T_VarDefList sem_VarDefList list = (Prelude.foldr sem_VarDefList_Cons sem_VarDefList_Nil (Prelude.map sem_VarDef list) ) -- semantic domain type T_VarDefList = Environment -> LocalIdentifierBindings -> ( VarDefList,([(String,Type)]),VarDefList) data Inh_VarDefList = Inh_VarDefList {env_Inh_VarDefList :: Environment,lib_Inh_VarDefList :: LocalIdentifierBindings} data Syn_VarDefList = Syn_VarDefList {annotatedTree_Syn_VarDefList :: VarDefList,defs_Syn_VarDefList :: [(String,Type)],originalTree_Syn_VarDefList :: VarDefList} wrap_VarDefList :: T_VarDefList -> Inh_VarDefList -> Syn_VarDefList wrap_VarDefList sem (Inh_VarDefList _lhsIenv _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOdefs,_lhsOoriginalTree) = (sem _lhsIenv _lhsIlib ) in (Syn_VarDefList _lhsOannotatedTree _lhsOdefs _lhsOoriginalTree )) sem_VarDefList_Cons :: T_VarDef -> T_VarDefList -> T_VarDefList sem_VarDefList_Cons hd_ tl_ = (\ _lhsIenv _lhsIlib -> (let _lhsOdefs :: ([(String,Type)]) _lhsOannotatedTree :: VarDefList _lhsOoriginalTree :: VarDefList _hdOenv :: Environment _hdOlib :: LocalIdentifierBindings _tlOenv :: Environment _tlOlib :: LocalIdentifierBindings _hdIannotatedTree :: VarDef _hdIdef :: ((String,Type)) _hdIoriginalTree :: VarDef _tlIannotatedTree :: VarDefList _tlIdefs :: ([(String,Type)]) _tlIoriginalTree :: VarDefList -- "./TypeChecking/CreateFunction.ag"(line 134, column 12) _lhsOdefs = {-# LINE 134 "./TypeChecking/CreateFunction.ag" #-} _hdIdef : _tlIdefs {-# LINE 15781 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} (:) _hdIannotatedTree _tlIannotatedTree {-# LINE 15786 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} (:) _hdIoriginalTree _tlIoriginalTree {-# LINE 15791 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 15796 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 15801 "AstInternal.hs" #-} -- copy rule (down) _hdOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 15806 "AstInternal.hs" #-} -- copy rule (down) _hdOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 15811 "AstInternal.hs" #-} -- copy rule (down) _tlOenv = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIenv {-# LINE 15816 "AstInternal.hs" #-} -- copy rule (down) _tlOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 15821 "AstInternal.hs" #-} ( _hdIannotatedTree,_hdIdef,_hdIoriginalTree) = (hd_ _hdOenv _hdOlib ) ( _tlIannotatedTree,_tlIdefs,_tlIoriginalTree) = (tl_ _tlOenv _tlOlib ) in ( _lhsOannotatedTree,_lhsOdefs,_lhsOoriginalTree))) sem_VarDefList_Nil :: T_VarDefList sem_VarDefList_Nil = (\ _lhsIenv _lhsIlib -> (let _lhsOdefs :: ([(String,Type)]) _lhsOannotatedTree :: VarDefList _lhsOoriginalTree :: VarDefList -- "./TypeChecking/CreateFunction.ag"(line 135, column 11) _lhsOdefs = {-# LINE 135 "./TypeChecking/CreateFunction.ag" #-} [] {-# LINE 15838 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 15843 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 15848 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 15853 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 15858 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOdefs,_lhsOoriginalTree))) -- Volatility -------------------------------------------------- {- visit 0: inherited attributes: env : Environment lib : LocalIdentifierBindings synthesized attributes: annotatedTree : SELF originalTree : SELF alternatives: alternative Immutable: visit 0: local annotatedTree : _ local originalTree : _ alternative Stable: visit 0: local annotatedTree : _ local originalTree : _ alternative Volatile: visit 0: local annotatedTree : _ local originalTree : _ -} data Volatility = Immutable | Stable | Volatile deriving ( Data,Eq,Show,Typeable) -- cata sem_Volatility :: Volatility -> T_Volatility sem_Volatility (Immutable ) = (sem_Volatility_Immutable ) sem_Volatility (Stable ) = (sem_Volatility_Stable ) sem_Volatility (Volatile ) = (sem_Volatility_Volatile ) -- semantic domain type T_Volatility = Environment -> LocalIdentifierBindings -> ( Volatility,Volatility) data Inh_Volatility = Inh_Volatility {env_Inh_Volatility :: Environment,lib_Inh_Volatility :: LocalIdentifierBindings} data Syn_Volatility = Syn_Volatility {annotatedTree_Syn_Volatility :: Volatility,originalTree_Syn_Volatility :: Volatility} wrap_Volatility :: T_Volatility -> Inh_Volatility -> Syn_Volatility wrap_Volatility sem (Inh_Volatility _lhsIenv _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIenv _lhsIlib ) in (Syn_Volatility _lhsOannotatedTree _lhsOoriginalTree )) sem_Volatility_Immutable :: T_Volatility sem_Volatility_Immutable = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: Volatility _lhsOoriginalTree :: Volatility -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Immutable {-# LINE 15919 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Immutable {-# LINE 15924 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 15929 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 15934 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_Volatility_Stable :: T_Volatility sem_Volatility_Stable = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: Volatility _lhsOoriginalTree :: Volatility -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Stable {-# LINE 15946 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Stable {-# LINE 15951 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 15956 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 15961 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_Volatility_Volatile :: T_Volatility sem_Volatility_Volatile = (\ _lhsIenv _lhsIlib -> (let _lhsOannotatedTree :: Volatility _lhsOoriginalTree :: Volatility -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Volatile {-# LINE 15973 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Volatile {-# LINE 15978 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 15983 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 15988 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree)))