-- UUAGC 0.9.13 (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 Data.Either import Control.Applicative import Data.Generics import Data.Char import Control.Monad.State 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.Catalog.CatalogInternal import Database.HsSqlPpp.AstInternals.TypeChecking.LocalIdentifierBindings --import Database.HsSqlPpp.AstInternals.Catalog.DefaultTemplate1Catalog 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 :: Catalog -> [StatementList] -> [StatementList] typeCheckMany cat sts = annInt cat 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 :: Catalog -> StatementList -> (Catalog,StatementList) typeCheck cat sts = let t = sem_Root (Root (fixupImplicitJoins sts)) ta = wrap_Root t Inh_Root {cat_Inh_Root = cat ,lib_Inh_Root = emptyBindings} tl = annotatedTree_Syn_Root ta cat1 = producedCat_Syn_Root ta in case tl of Root r -> (cat1,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 :: Catalog -> Statement -> Either String Statement typeCheckPS cat 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 {cat_Inh_Root = cat ,lib_Inh_Root = emptyBindings} tl = annotatedTree_Syn_Root ta cat1 = producedCat_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 :: Catalog -> Expression -> Expression typeCheckExpression cat ex = let t = sem_ExpressionRoot (ExpressionRoot (fixupImplicitJoins ex)) rt = (annotatedTree_Syn_ExpressionRoot (wrap_ExpressionRoot t Inh_ExpressionRoot {cat_Inh_ExpressionRoot = cat ,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 190 "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) ++) {- ================================================================================ proper dodgy: 1st pass is to add inferred types to the tree. This is done only for expressions in a funcall argument list atm. Then we pull out the placeholders after they've had this information added. Only the placeholders in funcall argument lists will have their type inferred in this way, to be expanded. Insert also does this currently, but in Dml.ag This should probably be done during the typechecking phase instead, but probably needs a proper type inferencing algorithm to be used, is done like this for development expediency. -} getPlaceholders :: Data a => a -> [Expression] getPlaceholders st = filter isPlaceholder $ everything (++) (mkQ [] ga) (setInferredTypes st) where ga :: Expression -> [Expression] ga s = [s] isPlaceholder e = case e of PositionalArg _ _ -> True Placeholder _ -> True _ -> False getPlaceholderTypes :: Data a => a -> [Type] getPlaceholderTypes ex = map (getInferredType . getAnnotation) $ getPlaceholders ex where getInferredType (InferredType t:_) = t getInferredType (_:as) = getInferredType as getInferredType [] = TypeCheckFailed setInferredTypes :: Data a => a -> a setInferredTypes = doExprs {-. doSts-} where doExprs = transformBi (\x -> case x of FunCall an op exprs -> FunCall an op (addInferredTypes an exprs) x1 -> x1) {-doSts = transformBi (\x -> case x of Insert ann table targetCols insData returning -> Insert ann table targetCols insData returning x1 -> x1)-} addInferredTypes an exprs = let args1 = fmap (\(_,a,_,_) -> a) $ fp an args = fromMaybe [] args1 fargs = args ++ repeat TypeCheckFailed in flip map (zip exprs fargs) (\(ex, ty) -> updateAnnotation (++ [InferredType ty]) ex) where fp (FunctionPrototypeA f:_) = Just f fp (_:ls) = fp ls fp [] = Nothing {-# LINE 283 "AstInternal.hs" #-} {-# LINE 94 "./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 :: Catalog -> String -> [Type] -> Either [TypeError] FunctionPrototype typeCheckFunCall cat 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 ("count", argsType, typeBigInt, False) "!between" -> do f1 <- lookupReturnType ">=" [argsType !! 0, argsType !! 1] f2 <- lookupReturnType "<=" [argsType !! 0, argsType !! 2] lookupFn "!and" [f1,f2] "greatest" -> do fp@(_,_,t,_) <- lookupFn fnName argsType lookupFn ">=" [t,t] return fp "least" -> do fp@(_,_,t,_) <- lookupFn fnName argsType lookupFn "<=" [t,t] return fp "!rowctor" -> return $ ("!rowCtor", argsType, AnonymousRecordType argsType, False) -- 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 cat (head argsType) (head $ tail argsType) -> return (fnName, argsType, typeBool, False) --checked for all special cases, so run general case now s -> lookupFn s argsType where lookupReturnType :: String -> [Type] -> Either [TypeError] Type lookupReturnType s1 args = fmap (\(_,_,r,_) -> r) $ lookupFn s1 args lookupFn :: String -> [Type] -> Either [TypeError] FunctionPrototype lookupFn s1 args = findCallMatch cat (if s1 == "u-" then "-" else s1) args fnName = map toLower fnName' {-# LINE 345 "AstInternal.hs" #-} {-# LINE 138 "./TypeChecking/SelectStatement.ag" #-} typeCheckValuesExpr :: Catalog -> [[Type]] -> Either [TypeError] Type typeCheckValuesExpr cat rowsTs = let colNames = zipWith (++) (repeat "column") (map show [1..length $ head rowsTs]) in unionRelTypes cat rowsTs colNames typeCheckCombineSelect :: Catalog -> Type -> Type -> Either [TypeError] Type typeCheckCombineSelect cat 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 cat [colTypes1,colTypes2] colNames unionRelTypes :: Catalog -> [[Type]] -> [String] -> Either [TypeError] Type unionRelTypes cat 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 cat) (transpose rowsTs) >>= (return . SetOfType . CompositeType . zip colNames) {-# LINE 380 "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 :: Catalog -> String -> Expression -> Either [TypeError] (String,[(String,Type)]) funIdens cat 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) -> catCompositePublicAttrs cat [] 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 424 "AstInternal.hs" #-} {-# LINE 92 "./TypeChecking/SelectLists.ag" #-} expandStar :: LocalIdentifierBindings -> String -> Type -> [(String,Type)] -> [(String,Type)] expandStar cat colName colType types = fromRight types $ do let (correlationName,iden) = splitIdentifier colName newCols <- if iden == "*" then libExpandStar cat 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 459 "AstInternal.hs" #-} {-# LINE 96 "./TypeChecking/Dml.ag" #-} setInferredTypesG :: Data a => [Type] -> a -> a setInferredTypesG tys x = evalState (transformBiM f x) tys where f (p@(Placeholder _)) = do y:ys <- get put ys return $ updateAnnotation (++ [InferredType y]) p f z = return z {-# LINE 473 "AstInternal.hs" #-} {-# LINE 163 "./TypeChecking/Dml.ag" #-} getRowTypes :: [Type] -> [Type] getRowTypes [AnonymousRecordType ts] = ts getRowTypes ts = ts {-# LINE 480 "AstInternal.hs" #-} {-# LINE 202 "./TypeChecking/Dml.ag" #-} --small shortcut to help produce better errors? checkRelationExists :: Catalog -> String -> Either [TypeError] () checkRelationExists cat tbl = catCompositeDef cat relationComposites tbl >> return () --used by both insert and update checkColumnConsistency :: Catalog -> String -> [String] -> [(String,Type)] -> Either [TypeError] [(String,Type)] checkColumnConsistency cat tbl cols' insNameTypePairs = do ttcols <- lowerize <$> catCompositePublicAttrs cat [] 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 cat c b) typeTriples liftErrors errs return targetNameTypePairs where lowerize = map (\(a,b) -> (map toLower a,b)) {-# LINE 517 "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 528 "AstInternal.hs" #-} -- AlterTableAction -------------------------------------------- {- visit 0: inherited attributes: cat : Catalog 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 = Catalog -> LocalIdentifierBindings -> ( AlterTableAction,AlterTableAction) data Inh_AlterTableAction = Inh_AlterTableAction {cat_Inh_AlterTableAction :: Catalog,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 _lhsIcat _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIcat _lhsIlib ) in (Syn_AlterTableAction _lhsOannotatedTree _lhsOoriginalTree )) sem_AlterTableAction_AddConstraint :: Annotation -> T_Constraint -> T_AlterTableAction sem_AlterTableAction_AddConstraint ann_ con_ = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: AlterTableAction _lhsOoriginalTree :: AlterTableAction _conOcat :: Catalog _conOlib :: LocalIdentifierBindings _conIannotatedTree :: Constraint _conIoriginalTree :: Constraint -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} AddConstraint ann_ _conIannotatedTree {-# LINE 592 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} AddConstraint ann_ _conIoriginalTree {-# LINE 597 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 602 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 607 "AstInternal.hs" #-} -- copy rule (down) _conOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 612 "AstInternal.hs" #-} -- copy rule (down) _conOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 617 "AstInternal.hs" #-} ( _conIannotatedTree,_conIoriginalTree) = (con_ _conOcat _conOlib ) in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_AlterTableAction_AlterColumnDefault :: Annotation -> String -> T_Expression -> T_AlterTableAction sem_AlterTableAction_AlterColumnDefault ann_ nm_ def_ = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: AlterTableAction _lhsOoriginalTree :: AlterTableAction _defOcat :: Catalog _defOlib :: LocalIdentifierBindings _defIannotatedTree :: Expression _defIliftedColumnName :: String _defIoriginalTree :: Expression -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} AlterColumnDefault ann_ nm_ _defIannotatedTree {-# LINE 639 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} AlterColumnDefault ann_ nm_ _defIoriginalTree {-# LINE 644 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 649 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 654 "AstInternal.hs" #-} -- copy rule (down) _defOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 659 "AstInternal.hs" #-} -- copy rule (down) _defOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 664 "AstInternal.hs" #-} ( _defIannotatedTree,_defIliftedColumnName,_defIoriginalTree) = (def_ _defOcat _defOlib ) in ( _lhsOannotatedTree,_lhsOoriginalTree))) -- AttributeDef ------------------------------------------------ {- visit 0: inherited attributes: cat : Catalog 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 = Catalog -> LocalIdentifierBindings -> ( AttributeDef,String,Type,AttributeDef) data Inh_AttributeDef = Inh_AttributeDef {cat_Inh_AttributeDef :: Catalog,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 _lhsIcat _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOattrName,_lhsOnamedType,_lhsOoriginalTree) = (sem _lhsIcat _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_ = (\ _lhsIcat _lhsIlib -> (let _lhsOattrName :: String _lhsOnamedType :: Type _consOlib :: LocalIdentifierBindings _lhsOannotatedTree :: AttributeDef _lhsOoriginalTree :: AttributeDef _typOcat :: Catalog _typOlib :: LocalIdentifierBindings _defOcat :: Catalog _defOlib :: LocalIdentifierBindings _consOcat :: Catalog _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 740 "AstInternal.hs" #-} -- "./TypeChecking/CreateTable.ag"(line 80, column 9) _lhsOnamedType = {-# LINE 80 "./TypeChecking/CreateTable.ag" #-} _typInamedType {-# LINE 745 "AstInternal.hs" #-} -- "./TypeChecking/CreateTable.ag"(line 95, column 9) _consOlib = {-# LINE 95 "./TypeChecking/CreateTable.ag" #-} case updateBindings _lhsIlib _lhsIcat [LibStackIDs [("", [(name_, _typInamedType)])]] of Left x -> error $ show x Right e -> e {-# LINE 753 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} AttributeDef ann_ name_ _typIannotatedTree _defIannotatedTree _consIannotatedTree {-# LINE 758 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} AttributeDef ann_ name_ _typIoriginalTree _defIoriginalTree _consIoriginalTree {-# LINE 763 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 768 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 773 "AstInternal.hs" #-} -- copy rule (down) _typOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 778 "AstInternal.hs" #-} -- copy rule (down) _typOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 783 "AstInternal.hs" #-} -- copy rule (down) _defOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 788 "AstInternal.hs" #-} -- copy rule (down) _defOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 793 "AstInternal.hs" #-} -- copy rule (down) _consOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 798 "AstInternal.hs" #-} ( _typIannotatedTree,_typInamedType,_typIoriginalTree) = (typ_ _typOcat _typOlib ) ( _defIannotatedTree,_defIoriginalTree) = (def_ _defOcat _defOlib ) ( _consIannotatedTree,_consIoriginalTree) = (cons_ _consOcat _consOlib ) in ( _lhsOannotatedTree,_lhsOattrName,_lhsOnamedType,_lhsOoriginalTree))) -- AttributeDefList -------------------------------------------- {- visit 0: inherited attributes: cat : Catalog 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 = Catalog -> LocalIdentifierBindings -> ( AttributeDefList,([(String, Type)]),AttributeDefList) data Inh_AttributeDefList = Inh_AttributeDefList {cat_Inh_AttributeDefList :: Catalog,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 _lhsIcat _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOattrs,_lhsOoriginalTree) = (sem _lhsIcat _lhsIlib ) in (Syn_AttributeDefList _lhsOannotatedTree _lhsOattrs _lhsOoriginalTree )) sem_AttributeDefList_Cons :: T_AttributeDef -> T_AttributeDefList -> T_AttributeDefList sem_AttributeDefList_Cons hd_ tl_ = (\ _lhsIcat _lhsIlib -> (let _lhsOattrs :: ([(String, Type)]) _lhsOannotatedTree :: AttributeDefList _lhsOoriginalTree :: AttributeDefList _hdOcat :: Catalog _hdOlib :: LocalIdentifierBindings _tlOcat :: Catalog _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 871 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} (:) _hdIannotatedTree _tlIannotatedTree {-# LINE 876 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} (:) _hdIoriginalTree _tlIoriginalTree {-# LINE 881 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 886 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 891 "AstInternal.hs" #-} -- copy rule (down) _hdOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 896 "AstInternal.hs" #-} -- copy rule (down) _hdOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 901 "AstInternal.hs" #-} -- copy rule (down) _tlOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 906 "AstInternal.hs" #-} -- copy rule (down) _tlOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 911 "AstInternal.hs" #-} ( _hdIannotatedTree,_hdIattrName,_hdInamedType,_hdIoriginalTree) = (hd_ _hdOcat _hdOlib ) ( _tlIannotatedTree,_tlIattrs,_tlIoriginalTree) = (tl_ _tlOcat _tlOlib ) in ( _lhsOannotatedTree,_lhsOattrs,_lhsOoriginalTree))) sem_AttributeDefList_Nil :: T_AttributeDefList sem_AttributeDefList_Nil = (\ _lhsIcat _lhsIlib -> (let _lhsOattrs :: ([(String, Type)]) _lhsOannotatedTree :: AttributeDefList _lhsOoriginalTree :: AttributeDefList -- "./TypeChecking/CreateTable.ag"(line 86, column 11) _lhsOattrs = {-# LINE 86 "./TypeChecking/CreateTable.ag" #-} [] {-# LINE 928 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 933 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 938 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 943 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 948 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOattrs,_lhsOoriginalTree))) -- Cascade ----------------------------------------------------- {- visit 0: inherited attributes: cat : Catalog 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 = Catalog -> LocalIdentifierBindings -> ( Cascade,Cascade) data Inh_Cascade = Inh_Cascade {cat_Inh_Cascade :: Catalog,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 _lhsIcat _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIcat _lhsIlib ) in (Syn_Cascade _lhsOannotatedTree _lhsOoriginalTree )) sem_Cascade_Cascade :: T_Cascade sem_Cascade_Cascade = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: Cascade _lhsOoriginalTree :: Cascade -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Cascade {-# LINE 1002 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Cascade {-# LINE 1007 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 1012 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 1017 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_Cascade_Restrict :: T_Cascade sem_Cascade_Restrict = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: Cascade _lhsOoriginalTree :: Cascade -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Restrict {-# LINE 1029 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Restrict {-# LINE 1034 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 1039 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 1044 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) -- CaseExpressionList ------------------------------------------ {- visit 0: inherited attributes: cat : Catalog 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 = Catalog -> LocalIdentifierBindings -> ( CaseExpressionList,CaseExpressionList) data Inh_CaseExpressionList = Inh_CaseExpressionList {cat_Inh_CaseExpressionList :: Catalog,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 _lhsIcat _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIcat _lhsIlib ) in (Syn_CaseExpressionList _lhsOannotatedTree _lhsOoriginalTree )) sem_CaseExpressionList_Cons :: T_Expression -> T_CaseExpressionList -> T_CaseExpressionList sem_CaseExpressionList_Cons hd_ tl_ = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: CaseExpressionList _lhsOoriginalTree :: CaseExpressionList _hdOcat :: Catalog _hdOlib :: LocalIdentifierBindings _tlOcat :: Catalog _tlOlib :: LocalIdentifierBindings _hdIannotatedTree :: Expression _hdIliftedColumnName :: String _hdIoriginalTree :: Expression _tlIannotatedTree :: CaseExpressionList _tlIoriginalTree :: CaseExpressionList -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} (:) _hdIannotatedTree _tlIannotatedTree {-# LINE 1107 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} (:) _hdIoriginalTree _tlIoriginalTree {-# LINE 1112 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 1117 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 1122 "AstInternal.hs" #-} -- copy rule (down) _hdOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 1127 "AstInternal.hs" #-} -- copy rule (down) _hdOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 1132 "AstInternal.hs" #-} -- copy rule (down) _tlOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 1137 "AstInternal.hs" #-} -- copy rule (down) _tlOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 1142 "AstInternal.hs" #-} ( _hdIannotatedTree,_hdIliftedColumnName,_hdIoriginalTree) = (hd_ _hdOcat _hdOlib ) ( _tlIannotatedTree,_tlIoriginalTree) = (tl_ _tlOcat _tlOlib ) in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_CaseExpressionList_Nil :: T_CaseExpressionList sem_CaseExpressionList_Nil = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: CaseExpressionList _lhsOoriginalTree :: CaseExpressionList -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 1158 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 1163 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 1168 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 1173 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) -- CaseExpressionListExpressionPair ---------------------------- {- visit 0: inherited attributes: cat : Catalog 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 = Catalog -> LocalIdentifierBindings -> ( CaseExpressionListExpressionPair,CaseExpressionListExpressionPair) data Inh_CaseExpressionListExpressionPair = Inh_CaseExpressionListExpressionPair {cat_Inh_CaseExpressionListExpressionPair :: Catalog,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 _lhsIcat _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIcat _lhsIlib ) in (Syn_CaseExpressionListExpressionPair _lhsOannotatedTree _lhsOoriginalTree )) sem_CaseExpressionListExpressionPair_Tuple :: T_CaseExpressionList -> T_Expression -> T_CaseExpressionListExpressionPair sem_CaseExpressionListExpressionPair_Tuple x1_ x2_ = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: CaseExpressionListExpressionPair _lhsOoriginalTree :: CaseExpressionListExpressionPair _x1Ocat :: Catalog _x1Olib :: LocalIdentifierBindings _x2Ocat :: Catalog _x2Olib :: LocalIdentifierBindings _x1IannotatedTree :: CaseExpressionList _x1IoriginalTree :: CaseExpressionList _x2IannotatedTree :: Expression _x2IliftedColumnName :: String _x2IoriginalTree :: Expression -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} (_x1IannotatedTree,_x2IannotatedTree) {-# LINE 1232 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} (_x1IoriginalTree,_x2IoriginalTree) {-# LINE 1237 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 1242 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 1247 "AstInternal.hs" #-} -- copy rule (down) _x1Ocat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 1252 "AstInternal.hs" #-} -- copy rule (down) _x1Olib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 1257 "AstInternal.hs" #-} -- copy rule (down) _x2Ocat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 1262 "AstInternal.hs" #-} -- copy rule (down) _x2Olib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 1267 "AstInternal.hs" #-} ( _x1IannotatedTree,_x1IoriginalTree) = (x1_ _x1Ocat _x1Olib ) ( _x2IannotatedTree,_x2IliftedColumnName,_x2IoriginalTree) = (x2_ _x2Ocat _x2Olib ) in ( _lhsOannotatedTree,_lhsOoriginalTree))) -- CaseExpressionListExpressionPairList ------------------------ {- visit 0: inherited attributes: cat : Catalog 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 = Catalog -> LocalIdentifierBindings -> ( CaseExpressionListExpressionPairList,CaseExpressionListExpressionPairList) data Inh_CaseExpressionListExpressionPairList = Inh_CaseExpressionListExpressionPairList {cat_Inh_CaseExpressionListExpressionPairList :: Catalog,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 _lhsIcat _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIcat _lhsIlib ) in (Syn_CaseExpressionListExpressionPairList _lhsOannotatedTree _lhsOoriginalTree )) sem_CaseExpressionListExpressionPairList_Cons :: T_CaseExpressionListExpressionPair -> T_CaseExpressionListExpressionPairList -> T_CaseExpressionListExpressionPairList sem_CaseExpressionListExpressionPairList_Cons hd_ tl_ = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: CaseExpressionListExpressionPairList _lhsOoriginalTree :: CaseExpressionListExpressionPairList _hdOcat :: Catalog _hdOlib :: LocalIdentifierBindings _tlOcat :: Catalog _tlOlib :: LocalIdentifierBindings _hdIannotatedTree :: CaseExpressionListExpressionPair _hdIoriginalTree :: CaseExpressionListExpressionPair _tlIannotatedTree :: CaseExpressionListExpressionPairList _tlIoriginalTree :: CaseExpressionListExpressionPairList -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} (:) _hdIannotatedTree _tlIannotatedTree {-# LINE 1333 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} (:) _hdIoriginalTree _tlIoriginalTree {-# LINE 1338 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 1343 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 1348 "AstInternal.hs" #-} -- copy rule (down) _hdOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 1353 "AstInternal.hs" #-} -- copy rule (down) _hdOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 1358 "AstInternal.hs" #-} -- copy rule (down) _tlOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 1363 "AstInternal.hs" #-} -- copy rule (down) _tlOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 1368 "AstInternal.hs" #-} ( _hdIannotatedTree,_hdIoriginalTree) = (hd_ _hdOcat _hdOlib ) ( _tlIannotatedTree,_tlIoriginalTree) = (tl_ _tlOcat _tlOlib ) in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_CaseExpressionListExpressionPairList_Nil :: T_CaseExpressionListExpressionPairList sem_CaseExpressionListExpressionPairList_Nil = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: CaseExpressionListExpressionPairList _lhsOoriginalTree :: CaseExpressionListExpressionPairList -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 1384 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 1389 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 1394 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 1399 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) -- CombineType ------------------------------------------------- {- visit 0: inherited attributes: cat : Catalog 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 = Catalog -> LocalIdentifierBindings -> ( CombineType,CombineType) data Inh_CombineType = Inh_CombineType {cat_Inh_CombineType :: Catalog,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 _lhsIcat _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIcat _lhsIlib ) in (Syn_CombineType _lhsOannotatedTree _lhsOoriginalTree )) sem_CombineType_Except :: T_CombineType sem_CombineType_Except = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: CombineType _lhsOoriginalTree :: CombineType -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Except {-# LINE 1467 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Except {-# LINE 1472 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 1477 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 1482 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_CombineType_Intersect :: T_CombineType sem_CombineType_Intersect = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: CombineType _lhsOoriginalTree :: CombineType -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Intersect {-# LINE 1494 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Intersect {-# LINE 1499 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 1504 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 1509 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_CombineType_Union :: T_CombineType sem_CombineType_Union = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: CombineType _lhsOoriginalTree :: CombineType -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Union {-# LINE 1521 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Union {-# LINE 1526 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 1531 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 1536 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_CombineType_UnionAll :: T_CombineType sem_CombineType_UnionAll = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: CombineType _lhsOoriginalTree :: CombineType -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} UnionAll {-# LINE 1548 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} UnionAll {-# LINE 1553 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 1558 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 1563 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) -- Constraint -------------------------------------------------- {- visit 0: inherited attributes: cat : Catalog 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 = Catalog -> LocalIdentifierBindings -> ( Constraint,Constraint) data Inh_Constraint = Inh_Constraint {cat_Inh_Constraint :: Catalog,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 _lhsIcat _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIcat _lhsIlib ) in (Syn_Constraint _lhsOannotatedTree _lhsOoriginalTree )) sem_Constraint_CheckConstraint :: Annotation -> String -> T_Expression -> T_Constraint sem_Constraint_CheckConstraint ann_ name_ expression_ = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: Constraint _lhsOoriginalTree :: Constraint _expressionOcat :: Catalog _expressionOlib :: LocalIdentifierBindings _expressionIannotatedTree :: Expression _expressionIliftedColumnName :: String _expressionIoriginalTree :: Expression -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} CheckConstraint ann_ name_ _expressionIannotatedTree {-# LINE 1655 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} CheckConstraint ann_ name_ _expressionIoriginalTree {-# LINE 1660 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 1665 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 1670 "AstInternal.hs" #-} -- copy rule (down) _expressionOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 1675 "AstInternal.hs" #-} -- copy rule (down) _expressionOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 1680 "AstInternal.hs" #-} ( _expressionIannotatedTree,_expressionIliftedColumnName,_expressionIoriginalTree) = (expression_ _expressionOcat _expressionOlib ) in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_Constraint_PrimaryKeyConstraint :: Annotation -> String -> T_StringList -> T_Constraint sem_Constraint_PrimaryKeyConstraint ann_ name_ stringList_ = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: Constraint _lhsOoriginalTree :: Constraint _stringListOcat :: Catalog _stringListOlib :: LocalIdentifierBindings _stringListIannotatedTree :: StringList _stringListIoriginalTree :: StringList _stringListIstrings :: ([String]) -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} PrimaryKeyConstraint ann_ name_ _stringListIannotatedTree {-# LINE 1702 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} PrimaryKeyConstraint ann_ name_ _stringListIoriginalTree {-# LINE 1707 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 1712 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 1717 "AstInternal.hs" #-} -- copy rule (down) _stringListOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 1722 "AstInternal.hs" #-} -- copy rule (down) _stringListOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 1727 "AstInternal.hs" #-} ( _stringListIannotatedTree,_stringListIoriginalTree,_stringListIstrings) = (stringList_ _stringListOcat _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_ = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: Constraint _lhsOoriginalTree :: Constraint _attsOcat :: Catalog _attsOlib :: LocalIdentifierBindings _tableAttsOcat :: Catalog _tableAttsOlib :: LocalIdentifierBindings _onUpdateOcat :: Catalog _onUpdateOlib :: LocalIdentifierBindings _onDeleteOcat :: Catalog _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 1766 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} ReferenceConstraint ann_ name_ _attsIoriginalTree table_ _tableAttsIoriginalTree _onUpdateIoriginalTree _onDeleteIoriginalTree {-# LINE 1771 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 1776 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 1781 "AstInternal.hs" #-} -- copy rule (down) _attsOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 1786 "AstInternal.hs" #-} -- copy rule (down) _attsOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 1791 "AstInternal.hs" #-} -- copy rule (down) _tableAttsOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 1796 "AstInternal.hs" #-} -- copy rule (down) _tableAttsOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 1801 "AstInternal.hs" #-} -- copy rule (down) _onUpdateOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 1806 "AstInternal.hs" #-} -- copy rule (down) _onUpdateOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 1811 "AstInternal.hs" #-} -- copy rule (down) _onDeleteOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 1816 "AstInternal.hs" #-} -- copy rule (down) _onDeleteOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 1821 "AstInternal.hs" #-} ( _attsIannotatedTree,_attsIoriginalTree,_attsIstrings) = (atts_ _attsOcat _attsOlib ) ( _tableAttsIannotatedTree,_tableAttsIoriginalTree,_tableAttsIstrings) = (tableAtts_ _tableAttsOcat _tableAttsOlib ) ( _onUpdateIannotatedTree,_onUpdateIoriginalTree) = (onUpdate_ _onUpdateOcat _onUpdateOlib ) ( _onDeleteIannotatedTree,_onDeleteIoriginalTree) = (onDelete_ _onDeleteOcat _onDeleteOlib ) in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_Constraint_UniqueConstraint :: Annotation -> String -> T_StringList -> T_Constraint sem_Constraint_UniqueConstraint ann_ name_ stringList_ = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: Constraint _lhsOoriginalTree :: Constraint _stringListOcat :: Catalog _stringListOlib :: LocalIdentifierBindings _stringListIannotatedTree :: StringList _stringListIoriginalTree :: StringList _stringListIstrings :: ([String]) -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} UniqueConstraint ann_ name_ _stringListIannotatedTree {-# LINE 1849 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} UniqueConstraint ann_ name_ _stringListIoriginalTree {-# LINE 1854 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 1859 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 1864 "AstInternal.hs" #-} -- copy rule (down) _stringListOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 1869 "AstInternal.hs" #-} -- copy rule (down) _stringListOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 1874 "AstInternal.hs" #-} ( _stringListIannotatedTree,_stringListIoriginalTree,_stringListIstrings) = (stringList_ _stringListOcat _stringListOlib ) in ( _lhsOannotatedTree,_lhsOoriginalTree))) -- ConstraintList ---------------------------------------------- {- visit 0: inherited attributes: cat : Catalog 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 = Catalog -> LocalIdentifierBindings -> ( ConstraintList,ConstraintList) data Inh_ConstraintList = Inh_ConstraintList {cat_Inh_ConstraintList :: Catalog,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 _lhsIcat _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIcat _lhsIlib ) in (Syn_ConstraintList _lhsOannotatedTree _lhsOoriginalTree )) sem_ConstraintList_Cons :: T_Constraint -> T_ConstraintList -> T_ConstraintList sem_ConstraintList_Cons hd_ tl_ = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: ConstraintList _lhsOoriginalTree :: ConstraintList _hdOcat :: Catalog _hdOlib :: LocalIdentifierBindings _tlOcat :: Catalog _tlOlib :: LocalIdentifierBindings _hdIannotatedTree :: Constraint _hdIoriginalTree :: Constraint _tlIannotatedTree :: ConstraintList _tlIoriginalTree :: ConstraintList -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} (:) _hdIannotatedTree _tlIannotatedTree {-# LINE 1938 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} (:) _hdIoriginalTree _tlIoriginalTree {-# LINE 1943 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 1948 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 1953 "AstInternal.hs" #-} -- copy rule (down) _hdOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 1958 "AstInternal.hs" #-} -- copy rule (down) _hdOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 1963 "AstInternal.hs" #-} -- copy rule (down) _tlOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 1968 "AstInternal.hs" #-} -- copy rule (down) _tlOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 1973 "AstInternal.hs" #-} ( _hdIannotatedTree,_hdIoriginalTree) = (hd_ _hdOcat _hdOlib ) ( _tlIannotatedTree,_tlIoriginalTree) = (tl_ _tlOcat _tlOlib ) in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_ConstraintList_Nil :: T_ConstraintList sem_ConstraintList_Nil = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: ConstraintList _lhsOoriginalTree :: ConstraintList -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 1989 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 1994 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 1999 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 2004 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) -- CopySource -------------------------------------------------- {- visit 0: inherited attributes: cat : Catalog 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 = Catalog -> LocalIdentifierBindings -> ( CopySource,CopySource) data Inh_CopySource = Inh_CopySource {cat_Inh_CopySource :: Catalog,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 _lhsIcat _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIcat _lhsIlib ) in (Syn_CopySource _lhsOannotatedTree _lhsOoriginalTree )) sem_CopySource_CopyFilename :: String -> T_CopySource sem_CopySource_CopyFilename string_ = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: CopySource _lhsOoriginalTree :: CopySource -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} CopyFilename string_ {-# LINE 2060 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} CopyFilename string_ {-# LINE 2065 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 2070 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 2075 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_CopySource_Stdin :: T_CopySource sem_CopySource_Stdin = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: CopySource _lhsOoriginalTree :: CopySource -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Stdin {-# LINE 2087 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Stdin {-# LINE 2092 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 2097 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 2102 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) -- Direction --------------------------------------------------- {- visit 0: inherited attributes: cat : Catalog 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 = Catalog -> LocalIdentifierBindings -> ( Direction,Direction) data Inh_Direction = Inh_Direction {cat_Inh_Direction :: Catalog,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 _lhsIcat _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIcat _lhsIlib ) in (Syn_Direction _lhsOannotatedTree _lhsOoriginalTree )) sem_Direction_Asc :: T_Direction sem_Direction_Asc = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: Direction _lhsOoriginalTree :: Direction -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Asc {-# LINE 2156 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Asc {-# LINE 2161 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 2166 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 2171 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_Direction_Desc :: T_Direction sem_Direction_Desc = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: Direction _lhsOoriginalTree :: Direction -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Desc {-# LINE 2183 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Desc {-# LINE 2188 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 2193 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 2198 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) -- Distinct ---------------------------------------------------- {- visit 0: inherited attributes: cat : Catalog 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 = Catalog -> LocalIdentifierBindings -> ( Distinct,Distinct) data Inh_Distinct = Inh_Distinct {cat_Inh_Distinct :: Catalog,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 _lhsIcat _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIcat _lhsIlib ) in (Syn_Distinct _lhsOannotatedTree _lhsOoriginalTree )) sem_Distinct_Distinct :: T_Distinct sem_Distinct_Distinct = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: Distinct _lhsOoriginalTree :: Distinct -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Distinct {-# LINE 2252 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Distinct {-# LINE 2257 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 2262 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 2267 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_Distinct_Dupes :: T_Distinct sem_Distinct_Dupes = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: Distinct _lhsOoriginalTree :: Distinct -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Dupes {-# LINE 2279 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Dupes {-# LINE 2284 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 2289 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 2294 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) -- DropType ---------------------------------------------------- {- visit 0: inherited attributes: cat : Catalog 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 = Catalog -> LocalIdentifierBindings -> ( DropType,DropType) data Inh_DropType = Inh_DropType {cat_Inh_DropType :: Catalog,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 _lhsIcat _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIcat _lhsIlib ) in (Syn_DropType _lhsOannotatedTree _lhsOoriginalTree )) sem_DropType_Domain :: T_DropType sem_DropType_Domain = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: DropType _lhsOoriginalTree :: DropType -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Domain {-# LINE 2362 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Domain {-# LINE 2367 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 2372 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 2377 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_DropType_Table :: T_DropType sem_DropType_Table = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: DropType _lhsOoriginalTree :: DropType -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Table {-# LINE 2389 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Table {-# LINE 2394 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 2399 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 2404 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_DropType_Type :: T_DropType sem_DropType_Type = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: DropType _lhsOoriginalTree :: DropType -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Type {-# LINE 2416 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Type {-# LINE 2421 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 2426 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 2431 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_DropType_View :: T_DropType sem_DropType_View = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: DropType _lhsOoriginalTree :: DropType -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} View {-# LINE 2443 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} View {-# LINE 2448 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 2453 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 2458 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) -- Expression -------------------------------------------------- {- visit 0: inherited attributes: cat : Catalog lib : LocalIdentifierBindings synthesized attributes: annotatedTree : SELF liftedColumnName : String originalTree : SELF alternatives: alternative BooleanLit: child ann : {Annotation} child b : {Bool} visit 0: local prototype : {Maybe FunctionPrototype} local tpe : _ local backTree : _ local annotatedTree : _ local originalTree : _ alternative Case: child ann : {Annotation} child cases : CaseExpressionListExpressionPairList child els : MaybeExpression visit 0: local prototype : {Maybe FunctionPrototype} 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 prototype : {Maybe FunctionPrototype} 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 prototype : {Maybe FunctionPrototype} local tpe : _ local backTree : _ local annotatedTree : _ local originalTree : _ alternative Exists: child ann : {Annotation} child sel : SelectExpression visit 0: local prototype : {Maybe FunctionPrototype} local tpe : _ local backTree : _ local annotatedTree : _ local originalTree : _ alternative FloatLit: child ann : {Annotation} child d : {Double} visit 0: local prototype : {Maybe FunctionPrototype} local tpe : _ local backTree : _ local annotatedTree : _ local originalTree : _ alternative FunCall: child ann : {Annotation} child funName : {String} child args : ExpressionList visit 0: local _tup1 : _ local tpe : _ local prototype : {Maybe FunctionPrototype} local backTree : _ local annotatedTree : _ local originalTree : _ alternative Identifier: child ann : {Annotation} child i : {String} visit 0: local prototype : {Maybe FunctionPrototype} 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 prototype : {Maybe FunctionPrototype} local tpe : _ local backTree : _ local annotatedTree : _ local originalTree : _ alternative IntegerLit: child ann : {Annotation} child i : {Integer} visit 0: local prototype : {Maybe FunctionPrototype} 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 prototype : {Maybe FunctionPrototype} local tpe : _ local backTree : _ local annotatedTree : _ local originalTree : _ alternative NullLit: child ann : {Annotation} visit 0: local prototype : {Maybe FunctionPrototype} local tpe : _ local backTree : _ local annotatedTree : _ local originalTree : _ alternative Placeholder: child ann : {Annotation} visit 0: local prototype : {Maybe FunctionPrototype} local tpe : _ local backTree : _ local annotatedTree : _ local originalTree : _ alternative PositionalArg: child ann : {Annotation} child p : {Integer} visit 0: local prototype : {Maybe FunctionPrototype} local tpe : _ local backTree : _ local annotatedTree : _ local originalTree : _ alternative ScalarSubQuery: child ann : {Annotation} child sel : SelectExpression visit 0: local prototype : {Maybe FunctionPrototype} local tpe : _ local backTree : _ local annotatedTree : _ local originalTree : _ alternative StringLit: child ann : {Annotation} child quote : {String} child value : {String} visit 0: local prototype : {Maybe FunctionPrototype} 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 prototype : {Maybe FunctionPrototype} 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 = Catalog -> LocalIdentifierBindings -> ( Expression,String,Expression) data Inh_Expression = Inh_Expression {cat_Inh_Expression :: Catalog,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 _lhsIcat _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOliftedColumnName,_lhsOoriginalTree) = (sem _lhsIcat _lhsIlib ) in (Syn_Expression _lhsOannotatedTree _lhsOliftedColumnName _lhsOoriginalTree )) sem_Expression_BooleanLit :: Annotation -> Bool -> T_Expression sem_Expression_BooleanLit ann_ b_ = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: Expression _prototype :: (Maybe FunctionPrototype) _lhsOliftedColumnName :: String _lhsOoriginalTree :: Expression -- "./TypeChecking/Expressions.ag"(line 14, column 9) _lhsOannotatedTree = {-# LINE 14 "./TypeChecking/Expressions.ag" #-} annTypesAndErrors _backTree (tpeToT _tpe ) (getErrors _tpe ) $ fmap ((:[]) . FunctionPrototypeA) _prototype {-# LINE 2727 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 29, column 9) _prototype = {-# LINE 29 "./TypeChecking/Expressions.ag" #-} Nothing {-# LINE 2732 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 41, column 19) _tpe = {-# LINE 41 "./TypeChecking/Expressions.ag" #-} Right typeBool {-# LINE 2737 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 53, column 9) _backTree = {-# LINE 53 "./TypeChecking/Expressions.ag" #-} BooleanLit ann_ b_ {-# LINE 2742 "AstInternal.hs" #-} -- "./TypeChecking/SelectLists.ag"(line 177, column 7) _lhsOliftedColumnName = {-# LINE 177 "./TypeChecking/SelectLists.ag" #-} "" {-# LINE 2747 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} BooleanLit ann_ b_ {-# LINE 2752 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} BooleanLit ann_ b_ {-# LINE 2757 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 2762 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOliftedColumnName,_lhsOoriginalTree))) sem_Expression_Case :: Annotation -> T_CaseExpressionListExpressionPairList -> T_MaybeExpression -> T_Expression sem_Expression_Case ann_ cases_ els_ = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: Expression _prototype :: (Maybe FunctionPrototype) _lhsOliftedColumnName :: String _lhsOoriginalTree :: Expression _casesOcat :: Catalog _casesOlib :: LocalIdentifierBindings _elsOcat :: Catalog _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 ) $ fmap ((:[]) . FunctionPrototypeA) _prototype {-# LINE 2790 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 29, column 9) _prototype = {-# LINE 29 "./TypeChecking/Expressions.ag" #-} Nothing {-# LINE 2795 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 202, column 9) _whenTypes = {-# LINE 202 "./TypeChecking/Expressions.ag" #-} map getTypeAnnotation $ concatMap fst $ _casesIannotatedTree {-# LINE 2801 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 204, column 9) _thenTypes = {-# LINE 204 "./TypeChecking/Expressions.ag" #-} map getTypeAnnotation $ (map snd $ _casesIannotatedTree) ++ maybeToList _elsIannotatedTree {-# LINE 2808 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 210, column 9) _tpe = {-# LINE 210 "./TypeChecking/Expressions.ag" #-} dependsOnRTpe _whenTypes $ do errorWhen (any (/= typeBool) _whenTypes ) $ [WrongTypes typeBool _whenTypes ] dependsOnRTpe _thenTypes $ resolveResultSetType _lhsIcat _thenTypes {-# LINE 2817 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 216, column 9) _backTree = {-# LINE 216 "./TypeChecking/Expressions.ag" #-} Case ann_ _casesIannotatedTree _elsIannotatedTree {-# LINE 2822 "AstInternal.hs" #-} -- "./TypeChecking/SelectLists.ag"(line 177, column 7) _lhsOliftedColumnName = {-# LINE 177 "./TypeChecking/SelectLists.ag" #-} "" {-# LINE 2827 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Case ann_ _casesIannotatedTree _elsIannotatedTree {-# LINE 2832 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Case ann_ _casesIoriginalTree _elsIoriginalTree {-# LINE 2837 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 2842 "AstInternal.hs" #-} -- copy rule (down) _casesOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 2847 "AstInternal.hs" #-} -- copy rule (down) _casesOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 2852 "AstInternal.hs" #-} -- copy rule (down) _elsOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 2857 "AstInternal.hs" #-} -- copy rule (down) _elsOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 2862 "AstInternal.hs" #-} ( _casesIannotatedTree,_casesIoriginalTree) = (cases_ _casesOcat _casesOlib ) ( _elsIannotatedTree,_elsIoriginalTree) = (els_ _elsOcat _elsOlib ) in ( _lhsOannotatedTree,_lhsOliftedColumnName,_lhsOoriginalTree))) sem_Expression_CaseSimple :: Annotation -> T_Expression -> T_CaseExpressionListExpressionPairList -> T_MaybeExpression -> T_Expression sem_Expression_CaseSimple ann_ value_ cases_ els_ = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: Expression _prototype :: (Maybe FunctionPrototype) _lhsOoriginalTree :: Expression _lhsOliftedColumnName :: String _valueOcat :: Catalog _valueOlib :: LocalIdentifierBindings _casesOcat :: Catalog _casesOlib :: LocalIdentifierBindings _elsOcat :: Catalog _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 ) $ fmap ((:[]) . FunctionPrototypeA) _prototype {-# LINE 2900 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 29, column 9) _prototype = {-# LINE 29 "./TypeChecking/Expressions.ag" #-} Nothing {-# LINE 2905 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 202, column 9) _whenTypes = {-# LINE 202 "./TypeChecking/Expressions.ag" #-} map getTypeAnnotation $ concatMap fst $ _casesIannotatedTree {-# LINE 2911 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 204, column 9) _thenTypes = {-# LINE 204 "./TypeChecking/Expressions.ag" #-} map getTypeAnnotation $ (map snd $ _casesIannotatedTree) ++ maybeToList _elsIannotatedTree {-# LINE 2918 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 221, column 9) _tpe = {-# LINE 221 "./TypeChecking/Expressions.ag" #-} dependsOnRTpe _whenTypes $ do let valueType = getTypeAnnotation _valueIannotatedTree checkWhenTypes <- resolveResultSetType _lhsIcat (valueType : _whenTypes ) dependsOnRTpe _thenTypes $ resolveResultSetType _lhsIcat _thenTypes {-# LINE 2928 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 228, column 9) _backTree = {-# LINE 228 "./TypeChecking/Expressions.ag" #-} CaseSimple ann_ _valueIannotatedTree _casesIannotatedTree _elsIannotatedTree {-# LINE 2936 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} CaseSimple ann_ _valueIannotatedTree _casesIannotatedTree _elsIannotatedTree {-# LINE 2941 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} CaseSimple ann_ _valueIoriginalTree _casesIoriginalTree _elsIoriginalTree {-# LINE 2946 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 2951 "AstInternal.hs" #-} -- copy rule (up) _lhsOliftedColumnName = {-# LINE 161 "./TypeChecking/SelectLists.ag" #-} _valueIliftedColumnName {-# LINE 2956 "AstInternal.hs" #-} -- copy rule (down) _valueOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 2961 "AstInternal.hs" #-} -- copy rule (down) _valueOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 2966 "AstInternal.hs" #-} -- copy rule (down) _casesOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 2971 "AstInternal.hs" #-} -- copy rule (down) _casesOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 2976 "AstInternal.hs" #-} -- copy rule (down) _elsOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 2981 "AstInternal.hs" #-} -- copy rule (down) _elsOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 2986 "AstInternal.hs" #-} ( _valueIannotatedTree,_valueIliftedColumnName,_valueIoriginalTree) = (value_ _valueOcat _valueOlib ) ( _casesIannotatedTree,_casesIoriginalTree) = (cases_ _casesOcat _casesOlib ) ( _elsIannotatedTree,_elsIoriginalTree) = (els_ _elsOcat _elsOlib ) in ( _lhsOannotatedTree,_lhsOliftedColumnName,_lhsOoriginalTree))) sem_Expression_Cast :: Annotation -> T_Expression -> T_TypeName -> T_Expression sem_Expression_Cast ann_ expr_ tn_ = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: Expression _prototype :: (Maybe FunctionPrototype) _lhsOliftedColumnName :: String _lhsOoriginalTree :: Expression _exprOcat :: Catalog _exprOlib :: LocalIdentifierBindings _tnOcat :: Catalog _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 ) $ fmap ((:[]) . FunctionPrototypeA) _prototype {-# LINE 3022 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 29, column 9) _prototype = {-# LINE 29 "./TypeChecking/Expressions.ag" #-} Nothing {-# LINE 3027 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 66, column 12) _tpe = {-# LINE 66 "./TypeChecking/Expressions.ag" #-} Right $ _tnInamedType {-# LINE 3032 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 67, column 12) _backTree = {-# LINE 67 "./TypeChecking/Expressions.ag" #-} Cast ann_ _exprIannotatedTree _tnIannotatedTree {-# LINE 3037 "AstInternal.hs" #-} -- "./TypeChecking/SelectLists.ag"(line 169, column 10) _lhsOliftedColumnName = {-# LINE 169 "./TypeChecking/SelectLists.ag" #-} case _tnIannotatedTree of SimpleTypeName _ tn -> tn _ -> "" {-# LINE 3044 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Cast ann_ _exprIannotatedTree _tnIannotatedTree {-# LINE 3049 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Cast ann_ _exprIoriginalTree _tnIoriginalTree {-# LINE 3054 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 3059 "AstInternal.hs" #-} -- copy rule (down) _exprOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 3064 "AstInternal.hs" #-} -- copy rule (down) _exprOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 3069 "AstInternal.hs" #-} -- copy rule (down) _tnOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 3074 "AstInternal.hs" #-} -- copy rule (down) _tnOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 3079 "AstInternal.hs" #-} ( _exprIannotatedTree,_exprIliftedColumnName,_exprIoriginalTree) = (expr_ _exprOcat _exprOlib ) ( _tnIannotatedTree,_tnInamedType,_tnIoriginalTree) = (tn_ _tnOcat _tnOlib ) in ( _lhsOannotatedTree,_lhsOliftedColumnName,_lhsOoriginalTree))) sem_Expression_Exists :: Annotation -> T_SelectExpression -> T_Expression sem_Expression_Exists ann_ sel_ = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: Expression _prototype :: (Maybe FunctionPrototype) _lhsOliftedColumnName :: String _lhsOoriginalTree :: Expression _selOcat :: Catalog _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 ) $ fmap ((:[]) . FunctionPrototypeA) _prototype {-# LINE 3107 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 29, column 9) _prototype = {-# LINE 29 "./TypeChecking/Expressions.ag" #-} Nothing {-# LINE 3112 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 259, column 9) _tpe = {-# LINE 259 "./TypeChecking/Expressions.ag" #-} Right typeBool {-# LINE 3117 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 260, column 9) _backTree = {-# LINE 260 "./TypeChecking/Expressions.ag" #-} Exists ann_ _selIannotatedTree {-# LINE 3122 "AstInternal.hs" #-} -- "./TypeChecking/SelectLists.ag"(line 177, column 7) _lhsOliftedColumnName = {-# LINE 177 "./TypeChecking/SelectLists.ag" #-} "" {-# LINE 3127 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Exists ann_ _selIannotatedTree {-# LINE 3132 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Exists ann_ _selIoriginalTree {-# LINE 3137 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 3142 "AstInternal.hs" #-} -- copy rule (down) _selOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 3147 "AstInternal.hs" #-} -- copy rule (down) _selOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 3152 "AstInternal.hs" #-} ( _selIannotatedTree,_selIlibUpdates,_selIoriginalTree) = (sel_ _selOcat _selOlib ) in ( _lhsOannotatedTree,_lhsOliftedColumnName,_lhsOoriginalTree))) sem_Expression_FloatLit :: Annotation -> Double -> T_Expression sem_Expression_FloatLit ann_ d_ = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: Expression _prototype :: (Maybe FunctionPrototype) _lhsOliftedColumnName :: String _lhsOoriginalTree :: Expression -- "./TypeChecking/Expressions.ag"(line 14, column 9) _lhsOannotatedTree = {-# LINE 14 "./TypeChecking/Expressions.ag" #-} annTypesAndErrors _backTree (tpeToT _tpe ) (getErrors _tpe ) $ fmap ((:[]) . FunctionPrototypeA) _prototype {-# LINE 3173 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 29, column 9) _prototype = {-# LINE 29 "./TypeChecking/Expressions.ag" #-} Nothing {-# LINE 3178 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 40, column 17) _tpe = {-# LINE 40 "./TypeChecking/Expressions.ag" #-} Right typeNumeric {-# LINE 3183 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 51, column 9) _backTree = {-# LINE 51 "./TypeChecking/Expressions.ag" #-} FloatLit ann_ d_ {-# LINE 3188 "AstInternal.hs" #-} -- "./TypeChecking/SelectLists.ag"(line 177, column 7) _lhsOliftedColumnName = {-# LINE 177 "./TypeChecking/SelectLists.ag" #-} "" {-# LINE 3193 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} FloatLit ann_ d_ {-# LINE 3198 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} FloatLit ann_ d_ {-# LINE 3203 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 3208 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOliftedColumnName,_lhsOoriginalTree))) sem_Expression_FunCall :: Annotation -> String -> T_ExpressionList -> T_Expression sem_Expression_FunCall ann_ funName_ args_ = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: Expression _prototype :: (Maybe FunctionPrototype) _lhsOliftedColumnName :: String _lhsOoriginalTree :: Expression _argsOcat :: Catalog _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 ) $ fmap ((:[]) . FunctionPrototypeA) _prototype {-# LINE 3233 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 74, column 9) __tup1 = {-# LINE 74 "./TypeChecking/Expressions.ag" #-} if any (==TypeCheckFailed) _argsItypeList then (Right TypeCheckFailed, Nothing) else let fe = typeCheckFunCall _lhsIcat funName_ _argsItypeList in (dependsOnRTpe _argsItypeList $ fmap (\(_,_,r,_) -> r) fe ,eitherToMaybe fe) {-# LINE 3246 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 74, column 9) (_tpe,_) = {-# LINE 74 "./TypeChecking/Expressions.ag" #-} __tup1 {-# LINE 3251 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 74, column 9) (_,_prototype) = {-# LINE 74 "./TypeChecking/Expressions.ag" #-} __tup1 {-# LINE 3256 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 83, column 9) _backTree = {-# LINE 83 "./TypeChecking/Expressions.ag" #-} FunCall ann_ funName_ _argsIannotatedTree {-# LINE 3261 "AstInternal.hs" #-} -- "./TypeChecking/SelectLists.ag"(line 165, column 13) _lhsOliftedColumnName = {-# LINE 165 "./TypeChecking/SelectLists.ag" #-} if isOperatorName funName_ then "" else funName_ {-# LINE 3268 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} FunCall ann_ funName_ _argsIannotatedTree {-# LINE 3273 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} FunCall ann_ funName_ _argsIoriginalTree {-# LINE 3278 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 3283 "AstInternal.hs" #-} -- copy rule (down) _argsOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 3288 "AstInternal.hs" #-} -- copy rule (down) _argsOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 3293 "AstInternal.hs" #-} ( _argsIannotatedTree,_argsIoriginalTree,_argsItypeList) = (args_ _argsOcat _argsOlib ) in ( _lhsOannotatedTree,_lhsOliftedColumnName,_lhsOoriginalTree))) sem_Expression_Identifier :: Annotation -> String -> T_Expression sem_Expression_Identifier ann_ i_ = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: Expression _prototype :: (Maybe FunctionPrototype) _lhsOliftedColumnName :: String _lhsOoriginalTree :: Expression -- "./TypeChecking/Expressions.ag"(line 14, column 9) _lhsOannotatedTree = {-# LINE 14 "./TypeChecking/Expressions.ag" #-} annTypesAndErrors _backTree (tpeToT _tpe ) (getErrors _tpe ) $ fmap ((:[]) . FunctionPrototypeA) _prototype {-# LINE 3314 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 29, column 9) _prototype = {-# LINE 29 "./TypeChecking/Expressions.ag" #-} Nothing {-# LINE 3319 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 241, column 9) _tpe = {-# LINE 241 "./TypeChecking/Expressions.ag" #-} libLookupID _lhsIlib i_ {-# LINE 3324 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 242, column 9) _backTree = {-# LINE 242 "./TypeChecking/Expressions.ag" #-} Identifier ann_ i_ {-# LINE 3329 "AstInternal.hs" #-} -- "./TypeChecking/SelectLists.ag"(line 164, column 16) _lhsOliftedColumnName = {-# LINE 164 "./TypeChecking/SelectLists.ag" #-} i_ {-# LINE 3334 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Identifier ann_ i_ {-# LINE 3339 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Identifier ann_ i_ {-# LINE 3344 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 3349 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOliftedColumnName,_lhsOoriginalTree))) sem_Expression_InPredicate :: Annotation -> T_Expression -> Bool -> T_InList -> T_Expression sem_Expression_InPredicate ann_ expr_ i_ list_ = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: Expression _prototype :: (Maybe FunctionPrototype) _lhsOoriginalTree :: Expression _lhsOliftedColumnName :: String _exprOcat :: Catalog _exprOlib :: LocalIdentifierBindings _listOcat :: Catalog _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 ) $ fmap ((:[]) . FunctionPrototypeA) _prototype {-# LINE 3380 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 29, column 9) _prototype = {-# LINE 29 "./TypeChecking/Expressions.ag" #-} Nothing {-# LINE 3385 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 289, column 9) _tpe = {-# LINE 289 "./TypeChecking/Expressions.ag" #-} do lt <- _listIlistType ty <- resolveResultSetType _lhsIcat [getTypeAnnotation _exprIannotatedTree, lt] return typeBool {-# LINE 3395 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 295, column 9) _backTree = {-# LINE 295 "./TypeChecking/Expressions.ag" #-} InPredicate ann_ _exprIannotatedTree i_ _listIannotatedTree {-# LINE 3403 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} InPredicate ann_ _exprIannotatedTree i_ _listIannotatedTree {-# LINE 3408 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} InPredicate ann_ _exprIoriginalTree i_ _listIoriginalTree {-# LINE 3413 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 3418 "AstInternal.hs" #-} -- copy rule (up) _lhsOliftedColumnName = {-# LINE 161 "./TypeChecking/SelectLists.ag" #-} _exprIliftedColumnName {-# LINE 3423 "AstInternal.hs" #-} -- copy rule (down) _exprOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 3428 "AstInternal.hs" #-} -- copy rule (down) _exprOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 3433 "AstInternal.hs" #-} -- copy rule (down) _listOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 3438 "AstInternal.hs" #-} -- copy rule (down) _listOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 3443 "AstInternal.hs" #-} ( _exprIannotatedTree,_exprIliftedColumnName,_exprIoriginalTree) = (expr_ _exprOcat _exprOlib ) ( _listIannotatedTree,_listIlistType,_listIoriginalTree) = (list_ _listOcat _listOlib ) in ( _lhsOannotatedTree,_lhsOliftedColumnName,_lhsOoriginalTree))) sem_Expression_IntegerLit :: Annotation -> Integer -> T_Expression sem_Expression_IntegerLit ann_ i_ = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: Expression _prototype :: (Maybe FunctionPrototype) _lhsOliftedColumnName :: String _lhsOoriginalTree :: Expression -- "./TypeChecking/Expressions.ag"(line 14, column 9) _lhsOannotatedTree = {-# LINE 14 "./TypeChecking/Expressions.ag" #-} annTypesAndErrors _backTree (tpeToT _tpe ) (getErrors _tpe ) $ fmap ((:[]) . FunctionPrototypeA) _prototype {-# LINE 3466 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 29, column 9) _prototype = {-# LINE 29 "./TypeChecking/Expressions.ag" #-} Nothing {-# LINE 3471 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 38, column 19) _tpe = {-# LINE 38 "./TypeChecking/Expressions.ag" #-} Right typeInt {-# LINE 3476 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 47, column 9) _backTree = {-# LINE 47 "./TypeChecking/Expressions.ag" #-} IntegerLit ann_ i_ {-# LINE 3481 "AstInternal.hs" #-} -- "./TypeChecking/SelectLists.ag"(line 177, column 7) _lhsOliftedColumnName = {-# LINE 177 "./TypeChecking/SelectLists.ag" #-} "" {-# LINE 3486 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} IntegerLit ann_ i_ {-# LINE 3491 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} IntegerLit ann_ i_ {-# LINE 3496 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 3501 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOliftedColumnName,_lhsOoriginalTree))) sem_Expression_LiftOperator :: Annotation -> String -> T_LiftFlavour -> T_ExpressionList -> T_Expression sem_Expression_LiftOperator ann_ oper_ flav_ args_ = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: Expression _prototype :: (Maybe FunctionPrototype) _lhsOliftedColumnName :: String _lhsOoriginalTree :: Expression _flavOcat :: Catalog _flavOlib :: LocalIdentifierBindings _argsOcat :: Catalog _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 ) $ fmap ((:[]) . FunctionPrototypeA) _prototype {-# LINE 3531 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 29, column 9) _prototype = {-# LINE 29 "./TypeChecking/Expressions.ag" #-} Nothing {-# LINE 3536 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 167, column 9) _tpe = {-# LINE 167 "./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 <- fmap (\(_,_,r,_) -> r) $ typeCheckFunCall _lhsIcat oper_ [aType,elemType] errorWhen (resType /= typeBool) [AnyAllError $ "operator must have bool return, got " ++ show resType] return resType {-# LINE 3558 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 185, column 9) _backTree = {-# LINE 185 "./TypeChecking/Expressions.ag" #-} LiftOperator ann_ oper_ _flavIannotatedTree _argsIannotatedTree {-# LINE 3563 "AstInternal.hs" #-} -- "./TypeChecking/SelectLists.ag"(line 177, column 7) _lhsOliftedColumnName = {-# LINE 177 "./TypeChecking/SelectLists.ag" #-} "" {-# LINE 3568 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} LiftOperator ann_ oper_ _flavIannotatedTree _argsIannotatedTree {-# LINE 3573 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} LiftOperator ann_ oper_ _flavIoriginalTree _argsIoriginalTree {-# LINE 3578 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 3583 "AstInternal.hs" #-} -- copy rule (down) _flavOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 3588 "AstInternal.hs" #-} -- copy rule (down) _flavOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 3593 "AstInternal.hs" #-} -- copy rule (down) _argsOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 3598 "AstInternal.hs" #-} -- copy rule (down) _argsOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 3603 "AstInternal.hs" #-} ( _flavIannotatedTree,_flavIoriginalTree) = (flav_ _flavOcat _flavOlib ) ( _argsIannotatedTree,_argsIoriginalTree,_argsItypeList) = (args_ _argsOcat _argsOlib ) in ( _lhsOannotatedTree,_lhsOliftedColumnName,_lhsOoriginalTree))) sem_Expression_NullLit :: Annotation -> T_Expression sem_Expression_NullLit ann_ = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: Expression _prototype :: (Maybe FunctionPrototype) _lhsOliftedColumnName :: String _lhsOoriginalTree :: Expression -- "./TypeChecking/Expressions.ag"(line 14, column 9) _lhsOannotatedTree = {-# LINE 14 "./TypeChecking/Expressions.ag" #-} annTypesAndErrors _backTree (tpeToT _tpe ) (getErrors _tpe ) $ fmap ((:[]) . FunctionPrototypeA) _prototype {-# LINE 3625 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 29, column 9) _prototype = {-# LINE 29 "./TypeChecking/Expressions.ag" #-} Nothing {-# LINE 3630 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 43, column 16) _tpe = {-# LINE 43 "./TypeChecking/Expressions.ag" #-} Right UnknownType {-# LINE 3635 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 55, column 9) _backTree = {-# LINE 55 "./TypeChecking/Expressions.ag" #-} NullLit ann_ {-# LINE 3640 "AstInternal.hs" #-} -- "./TypeChecking/SelectLists.ag"(line 177, column 7) _lhsOliftedColumnName = {-# LINE 177 "./TypeChecking/SelectLists.ag" #-} "" {-# LINE 3645 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} NullLit ann_ {-# LINE 3650 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} NullLit ann_ {-# LINE 3655 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 3660 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOliftedColumnName,_lhsOoriginalTree))) sem_Expression_Placeholder :: Annotation -> T_Expression sem_Expression_Placeholder ann_ = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: Expression _prototype :: (Maybe FunctionPrototype) _lhsOliftedColumnName :: String _lhsOoriginalTree :: Expression -- "./TypeChecking/Expressions.ag"(line 14, column 9) _lhsOannotatedTree = {-# LINE 14 "./TypeChecking/Expressions.ag" #-} annTypesAndErrors _backTree (tpeToT _tpe ) (getErrors _tpe ) $ fmap ((:[]) . FunctionPrototypeA) _prototype {-# LINE 3678 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 29, column 9) _prototype = {-# LINE 29 "./TypeChecking/Expressions.ag" #-} Nothing {-# LINE 3683 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 253, column 9) _tpe = {-# LINE 253 "./TypeChecking/Expressions.ag" #-} Right UnknownType {-# LINE 3688 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 254, column 9) _backTree = {-# LINE 254 "./TypeChecking/Expressions.ag" #-} Placeholder ann_ {-# LINE 3693 "AstInternal.hs" #-} -- "./TypeChecking/SelectLists.ag"(line 177, column 7) _lhsOliftedColumnName = {-# LINE 177 "./TypeChecking/SelectLists.ag" #-} "" {-# LINE 3698 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Placeholder ann_ {-# LINE 3703 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Placeholder ann_ {-# LINE 3708 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 3713 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOliftedColumnName,_lhsOoriginalTree))) sem_Expression_PositionalArg :: Annotation -> Integer -> T_Expression sem_Expression_PositionalArg ann_ p_ = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: Expression _prototype :: (Maybe FunctionPrototype) _lhsOliftedColumnName :: String _lhsOoriginalTree :: Expression -- "./TypeChecking/Expressions.ag"(line 14, column 9) _lhsOannotatedTree = {-# LINE 14 "./TypeChecking/Expressions.ag" #-} annTypesAndErrors _backTree (tpeToT _tpe ) (getErrors _tpe ) $ fmap ((:[]) . FunctionPrototypeA) _prototype {-# LINE 3732 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 29, column 9) _prototype = {-# LINE 29 "./TypeChecking/Expressions.ag" #-} Nothing {-# LINE 3737 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 247, column 9) _tpe = {-# LINE 247 "./TypeChecking/Expressions.ag" #-} libLookupID _lhsIlib ('$':show p_) {-# LINE 3742 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 248, column 9) _backTree = {-# LINE 248 "./TypeChecking/Expressions.ag" #-} PositionalArg ann_ p_ {-# LINE 3747 "AstInternal.hs" #-} -- "./TypeChecking/SelectLists.ag"(line 177, column 7) _lhsOliftedColumnName = {-# LINE 177 "./TypeChecking/SelectLists.ag" #-} "" {-# LINE 3752 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} PositionalArg ann_ p_ {-# LINE 3757 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} PositionalArg ann_ p_ {-# LINE 3762 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 3767 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOliftedColumnName,_lhsOoriginalTree))) sem_Expression_ScalarSubQuery :: Annotation -> T_SelectExpression -> T_Expression sem_Expression_ScalarSubQuery ann_ sel_ = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: Expression _prototype :: (Maybe FunctionPrototype) _lhsOliftedColumnName :: String _lhsOoriginalTree :: Expression _selOcat :: Catalog _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 ) $ fmap ((:[]) . FunctionPrototypeA) _prototype {-# LINE 3791 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 29, column 9) _prototype = {-# LINE 29 "./TypeChecking/Expressions.ag" #-} Nothing {-# LINE 3796 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 271, column 9) _tpe = {-# LINE 271 "./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 3808 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 281, column 9) _backTree = {-# LINE 281 "./TypeChecking/Expressions.ag" #-} ScalarSubQuery ann_ _selIannotatedTree {-# LINE 3813 "AstInternal.hs" #-} -- "./TypeChecking/SelectLists.ag"(line 177, column 7) _lhsOliftedColumnName = {-# LINE 177 "./TypeChecking/SelectLists.ag" #-} "" {-# LINE 3818 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} ScalarSubQuery ann_ _selIannotatedTree {-# LINE 3823 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} ScalarSubQuery ann_ _selIoriginalTree {-# LINE 3828 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 3833 "AstInternal.hs" #-} -- copy rule (down) _selOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 3838 "AstInternal.hs" #-} -- copy rule (down) _selOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 3843 "AstInternal.hs" #-} ( _selIannotatedTree,_selIlibUpdates,_selIoriginalTree) = (sel_ _selOcat _selOlib ) in ( _lhsOannotatedTree,_lhsOliftedColumnName,_lhsOoriginalTree))) sem_Expression_StringLit :: Annotation -> String -> String -> T_Expression sem_Expression_StringLit ann_ quote_ value_ = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: Expression _prototype :: (Maybe FunctionPrototype) _lhsOliftedColumnName :: String _lhsOoriginalTree :: Expression -- "./TypeChecking/Expressions.ag"(line 14, column 9) _lhsOannotatedTree = {-# LINE 14 "./TypeChecking/Expressions.ag" #-} annTypesAndErrors _backTree (tpeToT _tpe ) (getErrors _tpe ) $ fmap ((:[]) . FunctionPrototypeA) _prototype {-# LINE 3865 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 29, column 9) _prototype = {-# LINE 29 "./TypeChecking/Expressions.ag" #-} Nothing {-# LINE 3870 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 39, column 18) _tpe = {-# LINE 39 "./TypeChecking/Expressions.ag" #-} Right UnknownType {-# LINE 3875 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 49, column 9) _backTree = {-# LINE 49 "./TypeChecking/Expressions.ag" #-} StringLit ann_ quote_ value_ {-# LINE 3880 "AstInternal.hs" #-} -- "./TypeChecking/SelectLists.ag"(line 177, column 7) _lhsOliftedColumnName = {-# LINE 177 "./TypeChecking/SelectLists.ag" #-} "" {-# LINE 3885 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} StringLit ann_ quote_ value_ {-# LINE 3890 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} StringLit ann_ quote_ value_ {-# LINE 3895 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 3900 "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_ = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: Expression _prototype :: (Maybe FunctionPrototype) _lhsOoriginalTree :: Expression _lhsOliftedColumnName :: String _fnOcat :: Catalog _fnOlib :: LocalIdentifierBindings _partitionByOcat :: Catalog _partitionByOlib :: LocalIdentifierBindings _orderByOcat :: Catalog _orderByOlib :: LocalIdentifierBindings _dirOcat :: Catalog _dirOlib :: LocalIdentifierBindings _frmOcat :: Catalog _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 ) $ fmap ((:[]) . FunctionPrototypeA) _prototype {-# LINE 3946 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 29, column 9) _prototype = {-# LINE 29 "./TypeChecking/Expressions.ag" #-} Nothing {-# LINE 3951 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 87, column 9) _tpe = {-# LINE 87 "./TypeChecking/Expressions.ag" #-} Right (getTypeAnnotation _fnIannotatedTree) {-# LINE 3956 "AstInternal.hs" #-} -- "./TypeChecking/Expressions.ag"(line 88, column 9) _backTree = {-# LINE 88 "./TypeChecking/Expressions.ag" #-} WindowFn ann_ _fnIannotatedTree _partitionByIannotatedTree _orderByIannotatedTree _dirIannotatedTree _frmIannotatedTree {-# LINE 3966 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} WindowFn ann_ _fnIannotatedTree _partitionByIannotatedTree _orderByIannotatedTree _dirIannotatedTree _frmIannotatedTree {-# LINE 3971 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} WindowFn ann_ _fnIoriginalTree _partitionByIoriginalTree _orderByIoriginalTree _dirIoriginalTree _frmIoriginalTree {-# LINE 3976 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 3981 "AstInternal.hs" #-} -- copy rule (up) _lhsOliftedColumnName = {-# LINE 161 "./TypeChecking/SelectLists.ag" #-} _fnIliftedColumnName {-# LINE 3986 "AstInternal.hs" #-} -- copy rule (down) _fnOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 3991 "AstInternal.hs" #-} -- copy rule (down) _fnOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 3996 "AstInternal.hs" #-} -- copy rule (down) _partitionByOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 4001 "AstInternal.hs" #-} -- copy rule (down) _partitionByOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 4006 "AstInternal.hs" #-} -- copy rule (down) _orderByOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 4011 "AstInternal.hs" #-} -- copy rule (down) _orderByOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 4016 "AstInternal.hs" #-} -- copy rule (down) _dirOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 4021 "AstInternal.hs" #-} -- copy rule (down) _dirOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 4026 "AstInternal.hs" #-} -- copy rule (down) _frmOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 4031 "AstInternal.hs" #-} -- copy rule (down) _frmOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 4036 "AstInternal.hs" #-} ( _fnIannotatedTree,_fnIliftedColumnName,_fnIoriginalTree) = (fn_ _fnOcat _fnOlib ) ( _partitionByIannotatedTree,_partitionByIoriginalTree,_partitionByItypeList) = (partitionBy_ _partitionByOcat _partitionByOlib ) ( _orderByIannotatedTree,_orderByIoriginalTree,_orderByItypeList) = (orderBy_ _orderByOcat _orderByOlib ) ( _dirIannotatedTree,_dirIoriginalTree) = (dir_ _dirOcat _dirOlib ) ( _frmIannotatedTree,_frmIoriginalTree) = (frm_ _frmOcat _frmOlib ) in ( _lhsOannotatedTree,_lhsOliftedColumnName,_lhsOoriginalTree))) -- ExpressionDirectionPair ------------------------------------- {- visit 0: inherited attributes: cat : Catalog 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 = Catalog -> LocalIdentifierBindings -> ( ExpressionDirectionPair,ExpressionDirectionPair) data Inh_ExpressionDirectionPair = Inh_ExpressionDirectionPair {cat_Inh_ExpressionDirectionPair :: Catalog,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 _lhsIcat _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIcat _lhsIlib ) in (Syn_ExpressionDirectionPair _lhsOannotatedTree _lhsOoriginalTree )) sem_ExpressionDirectionPair_Tuple :: T_Expression -> T_Direction -> T_ExpressionDirectionPair sem_ExpressionDirectionPair_Tuple x1_ x2_ = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: ExpressionDirectionPair _lhsOoriginalTree :: ExpressionDirectionPair _x1Ocat :: Catalog _x1Olib :: LocalIdentifierBindings _x2Ocat :: Catalog _x2Olib :: LocalIdentifierBindings _x1IannotatedTree :: Expression _x1IliftedColumnName :: String _x1IoriginalTree :: Expression _x2IannotatedTree :: Direction _x2IoriginalTree :: Direction -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} (_x1IannotatedTree,_x2IannotatedTree) {-# LINE 4105 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} (_x1IoriginalTree,_x2IoriginalTree) {-# LINE 4110 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 4115 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 4120 "AstInternal.hs" #-} -- copy rule (down) _x1Ocat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 4125 "AstInternal.hs" #-} -- copy rule (down) _x1Olib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 4130 "AstInternal.hs" #-} -- copy rule (down) _x2Ocat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 4135 "AstInternal.hs" #-} -- copy rule (down) _x2Olib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 4140 "AstInternal.hs" #-} ( _x1IannotatedTree,_x1IliftedColumnName,_x1IoriginalTree) = (x1_ _x1Ocat _x1Olib ) ( _x2IannotatedTree,_x2IoriginalTree) = (x2_ _x2Ocat _x2Olib ) in ( _lhsOannotatedTree,_lhsOoriginalTree))) -- ExpressionDirectionPairList --------------------------------- {- visit 0: inherited attributes: cat : Catalog 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 = Catalog -> LocalIdentifierBindings -> ( ExpressionDirectionPairList,ExpressionDirectionPairList) data Inh_ExpressionDirectionPairList = Inh_ExpressionDirectionPairList {cat_Inh_ExpressionDirectionPairList :: Catalog,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 _lhsIcat _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIcat _lhsIlib ) in (Syn_ExpressionDirectionPairList _lhsOannotatedTree _lhsOoriginalTree )) sem_ExpressionDirectionPairList_Cons :: T_ExpressionDirectionPair -> T_ExpressionDirectionPairList -> T_ExpressionDirectionPairList sem_ExpressionDirectionPairList_Cons hd_ tl_ = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: ExpressionDirectionPairList _lhsOoriginalTree :: ExpressionDirectionPairList _hdOcat :: Catalog _hdOlib :: LocalIdentifierBindings _tlOcat :: Catalog _tlOlib :: LocalIdentifierBindings _hdIannotatedTree :: ExpressionDirectionPair _hdIoriginalTree :: ExpressionDirectionPair _tlIannotatedTree :: ExpressionDirectionPairList _tlIoriginalTree :: ExpressionDirectionPairList -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} (:) _hdIannotatedTree _tlIannotatedTree {-# LINE 4206 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} (:) _hdIoriginalTree _tlIoriginalTree {-# LINE 4211 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 4216 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 4221 "AstInternal.hs" #-} -- copy rule (down) _hdOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 4226 "AstInternal.hs" #-} -- copy rule (down) _hdOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 4231 "AstInternal.hs" #-} -- copy rule (down) _tlOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 4236 "AstInternal.hs" #-} -- copy rule (down) _tlOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 4241 "AstInternal.hs" #-} ( _hdIannotatedTree,_hdIoriginalTree) = (hd_ _hdOcat _hdOlib ) ( _tlIannotatedTree,_tlIoriginalTree) = (tl_ _tlOcat _tlOlib ) in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_ExpressionDirectionPairList_Nil :: T_ExpressionDirectionPairList sem_ExpressionDirectionPairList_Nil = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: ExpressionDirectionPairList _lhsOoriginalTree :: ExpressionDirectionPairList -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 4257 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 4262 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 4267 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 4272 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) -- ExpressionList ---------------------------------------------- {- visit 0: inherited attributes: cat : Catalog 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 = Catalog -> LocalIdentifierBindings -> ( ExpressionList,ExpressionList,([Type])) data Inh_ExpressionList = Inh_ExpressionList {cat_Inh_ExpressionList :: Catalog,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 _lhsIcat _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree,_lhsOtypeList) = (sem _lhsIcat _lhsIlib ) in (Syn_ExpressionList _lhsOannotatedTree _lhsOoriginalTree _lhsOtypeList )) sem_ExpressionList_Cons :: T_Expression -> T_ExpressionList -> T_ExpressionList sem_ExpressionList_Cons hd_ tl_ = (\ _lhsIcat _lhsIlib -> (let _lhsOtypeList :: ([Type]) _lhsOannotatedTree :: ExpressionList _lhsOoriginalTree :: ExpressionList _hdOcat :: Catalog _hdOlib :: LocalIdentifierBindings _tlOcat :: Catalog _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 4338 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} (:) _hdIannotatedTree _tlIannotatedTree {-# LINE 4343 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} (:) _hdIoriginalTree _tlIoriginalTree {-# LINE 4348 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 4353 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 4358 "AstInternal.hs" #-} -- copy rule (down) _hdOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 4363 "AstInternal.hs" #-} -- copy rule (down) _hdOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 4368 "AstInternal.hs" #-} -- copy rule (down) _tlOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 4373 "AstInternal.hs" #-} -- copy rule (down) _tlOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 4378 "AstInternal.hs" #-} ( _hdIannotatedTree,_hdIliftedColumnName,_hdIoriginalTree) = (hd_ _hdOcat _hdOlib ) ( _tlIannotatedTree,_tlIoriginalTree,_tlItypeList) = (tl_ _tlOcat _tlOlib ) in ( _lhsOannotatedTree,_lhsOoriginalTree,_lhsOtypeList))) sem_ExpressionList_Nil :: T_ExpressionList sem_ExpressionList_Nil = (\ _lhsIcat _lhsIlib -> (let _lhsOtypeList :: ([Type]) _lhsOannotatedTree :: ExpressionList _lhsOoriginalTree :: ExpressionList -- "./TypeChecking/Misc.ag"(line 53, column 11) _lhsOtypeList = {-# LINE 53 "./TypeChecking/Misc.ag" #-} [] {-# LINE 4395 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 4400 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 4405 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 4410 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 4415 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree,_lhsOtypeList))) -- ExpressionListList ------------------------------------------ {- visit 0: inherited attributes: cat : Catalog 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 = Catalog -> LocalIdentifierBindings -> ( ExpressionListList,ExpressionListList,([[Type]])) data Inh_ExpressionListList = Inh_ExpressionListList {cat_Inh_ExpressionListList :: Catalog,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 _lhsIcat _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree,_lhsOtypeListList) = (sem _lhsIcat _lhsIlib ) in (Syn_ExpressionListList _lhsOannotatedTree _lhsOoriginalTree _lhsOtypeListList )) sem_ExpressionListList_Cons :: T_ExpressionList -> T_ExpressionListList -> T_ExpressionListList sem_ExpressionListList_Cons hd_ tl_ = (\ _lhsIcat _lhsIlib -> (let _lhsOtypeListList :: ([[Type]]) _lhsOannotatedTree :: ExpressionListList _lhsOoriginalTree :: ExpressionListList _hdOcat :: Catalog _hdOlib :: LocalIdentifierBindings _tlOcat :: Catalog _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 4481 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} (:) _hdIannotatedTree _tlIannotatedTree {-# LINE 4486 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} (:) _hdIoriginalTree _tlIoriginalTree {-# LINE 4491 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 4496 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 4501 "AstInternal.hs" #-} -- copy rule (down) _hdOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 4506 "AstInternal.hs" #-} -- copy rule (down) _hdOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 4511 "AstInternal.hs" #-} -- copy rule (down) _tlOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 4516 "AstInternal.hs" #-} -- copy rule (down) _tlOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 4521 "AstInternal.hs" #-} ( _hdIannotatedTree,_hdIoriginalTree,_hdItypeList) = (hd_ _hdOcat _hdOlib ) ( _tlIannotatedTree,_tlIoriginalTree,_tlItypeListList) = (tl_ _tlOcat _tlOlib ) in ( _lhsOannotatedTree,_lhsOoriginalTree,_lhsOtypeListList))) sem_ExpressionListList_Nil :: T_ExpressionListList sem_ExpressionListList_Nil = (\ _lhsIcat _lhsIlib -> (let _lhsOtypeListList :: ([[Type]]) _lhsOannotatedTree :: ExpressionListList _lhsOoriginalTree :: ExpressionListList -- "./TypeChecking/Misc.ag"(line 60, column 11) _lhsOtypeListList = {-# LINE 60 "./TypeChecking/Misc.ag" #-} [] {-# LINE 4538 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 4543 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 4548 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 4553 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 4558 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree,_lhsOtypeListList))) -- ExpressionListStatementListPair ----------------------------- {- visit 0: inherited attributes: cat : Catalog 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 = Catalog -> LocalIdentifierBindings -> ( ExpressionListStatementListPair,ExpressionListStatementListPair) data Inh_ExpressionListStatementListPair = Inh_ExpressionListStatementListPair {cat_Inh_ExpressionListStatementListPair :: Catalog,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 _lhsIcat _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIcat _lhsIlib ) in (Syn_ExpressionListStatementListPair _lhsOannotatedTree _lhsOoriginalTree )) sem_ExpressionListStatementListPair_Tuple :: T_ExpressionList -> T_StatementList -> T_ExpressionListStatementListPair sem_ExpressionListStatementListPair_Tuple x1_ x2_ = (\ _lhsIcat _lhsIlib -> (let _x2OcatUpdates :: ([CatalogUpdate]) _x2OlibUpdates :: ([LocalIdentifierBindingsUpdate]) _lhsOannotatedTree :: ExpressionListStatementListPair _lhsOoriginalTree :: ExpressionListStatementListPair _x1Ocat :: Catalog _x1Olib :: LocalIdentifierBindings _x2Ocat :: Catalog _x2Olib :: LocalIdentifierBindings _x1IannotatedTree :: ExpressionList _x1IoriginalTree :: ExpressionList _x1ItypeList :: ([Type]) _x2IannotatedTree :: StatementList _x2IoriginalTree :: StatementList _x2IproducedCat :: Catalog _x2IproducedLib :: LocalIdentifierBindings -- "./TypeChecking/Statements.ag"(line 94, column 9) _x2OcatUpdates = {-# LINE 94 "./TypeChecking/Statements.ag" #-} [] {-# LINE 4621 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 95, column 9) _x2OlibUpdates = {-# LINE 95 "./TypeChecking/Statements.ag" #-} [] {-# LINE 4626 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} (_x1IannotatedTree,_x2IannotatedTree) {-# LINE 4631 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} (_x1IoriginalTree,_x2IoriginalTree) {-# LINE 4636 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 4641 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 4646 "AstInternal.hs" #-} -- copy rule (down) _x1Ocat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 4651 "AstInternal.hs" #-} -- copy rule (down) _x1Olib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 4656 "AstInternal.hs" #-} -- copy rule (down) _x2Ocat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 4661 "AstInternal.hs" #-} -- copy rule (down) _x2Olib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 4666 "AstInternal.hs" #-} ( _x1IannotatedTree,_x1IoriginalTree,_x1ItypeList) = (x1_ _x1Ocat _x1Olib ) ( _x2IannotatedTree,_x2IoriginalTree,_x2IproducedCat,_x2IproducedLib) = (x2_ _x2Ocat _x2OcatUpdates _x2Olib _x2OlibUpdates ) in ( _lhsOannotatedTree,_lhsOoriginalTree))) -- ExpressionListStatementListPairList ------------------------- {- visit 0: inherited attributes: cat : Catalog 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 = Catalog -> LocalIdentifierBindings -> ( ExpressionListStatementListPairList,ExpressionListStatementListPairList) data Inh_ExpressionListStatementListPairList = Inh_ExpressionListStatementListPairList {cat_Inh_ExpressionListStatementListPairList :: Catalog,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 _lhsIcat _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIcat _lhsIlib ) in (Syn_ExpressionListStatementListPairList _lhsOannotatedTree _lhsOoriginalTree )) sem_ExpressionListStatementListPairList_Cons :: T_ExpressionListStatementListPair -> T_ExpressionListStatementListPairList -> T_ExpressionListStatementListPairList sem_ExpressionListStatementListPairList_Cons hd_ tl_ = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: ExpressionListStatementListPairList _lhsOoriginalTree :: ExpressionListStatementListPairList _hdOcat :: Catalog _hdOlib :: LocalIdentifierBindings _tlOcat :: Catalog _tlOlib :: LocalIdentifierBindings _hdIannotatedTree :: ExpressionListStatementListPair _hdIoriginalTree :: ExpressionListStatementListPair _tlIannotatedTree :: ExpressionListStatementListPairList _tlIoriginalTree :: ExpressionListStatementListPairList -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} (:) _hdIannotatedTree _tlIannotatedTree {-# LINE 4732 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} (:) _hdIoriginalTree _tlIoriginalTree {-# LINE 4737 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 4742 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 4747 "AstInternal.hs" #-} -- copy rule (down) _hdOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 4752 "AstInternal.hs" #-} -- copy rule (down) _hdOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 4757 "AstInternal.hs" #-} -- copy rule (down) _tlOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 4762 "AstInternal.hs" #-} -- copy rule (down) _tlOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 4767 "AstInternal.hs" #-} ( _hdIannotatedTree,_hdIoriginalTree) = (hd_ _hdOcat _hdOlib ) ( _tlIannotatedTree,_tlIoriginalTree) = (tl_ _tlOcat _tlOlib ) in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_ExpressionListStatementListPairList_Nil :: T_ExpressionListStatementListPairList sem_ExpressionListStatementListPairList_Nil = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: ExpressionListStatementListPairList _lhsOoriginalTree :: ExpressionListStatementListPairList -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 4783 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 4788 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 4793 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 4798 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) -- ExpressionRoot ---------------------------------------------- {- visit 0: inherited attributes: cat : Catalog 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 = Catalog -> LocalIdentifierBindings -> ( ExpressionRoot,ExpressionRoot) data Inh_ExpressionRoot = Inh_ExpressionRoot {cat_Inh_ExpressionRoot :: Catalog,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 _lhsIcat _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIcat _lhsIlib ) in (Syn_ExpressionRoot _lhsOannotatedTree _lhsOoriginalTree )) sem_ExpressionRoot_ExpressionRoot :: T_Expression -> T_ExpressionRoot sem_ExpressionRoot_ExpressionRoot expr_ = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: ExpressionRoot _lhsOoriginalTree :: ExpressionRoot _exprOcat :: Catalog _exprOlib :: LocalIdentifierBindings _exprIannotatedTree :: Expression _exprIliftedColumnName :: String _exprIoriginalTree :: Expression -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} ExpressionRoot _exprIannotatedTree {-# LINE 4852 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} ExpressionRoot _exprIoriginalTree {-# LINE 4857 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 4862 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 4867 "AstInternal.hs" #-} -- copy rule (down) _exprOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 4872 "AstInternal.hs" #-} -- copy rule (down) _exprOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 4877 "AstInternal.hs" #-} ( _exprIannotatedTree,_exprIliftedColumnName,_exprIoriginalTree) = (expr_ _exprOcat _exprOlib ) in ( _lhsOannotatedTree,_lhsOoriginalTree))) -- ExpressionStatementListPair --------------------------------- {- visit 0: inherited attributes: cat : Catalog 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 = Catalog -> LocalIdentifierBindings -> ( ExpressionStatementListPair,ExpressionStatementListPair) data Inh_ExpressionStatementListPair = Inh_ExpressionStatementListPair {cat_Inh_ExpressionStatementListPair :: Catalog,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 _lhsIcat _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIcat _lhsIlib ) in (Syn_ExpressionStatementListPair _lhsOannotatedTree _lhsOoriginalTree )) sem_ExpressionStatementListPair_Tuple :: T_Expression -> T_StatementList -> T_ExpressionStatementListPair sem_ExpressionStatementListPair_Tuple x1_ x2_ = (\ _lhsIcat _lhsIlib -> (let _x2OcatUpdates :: ([CatalogUpdate]) _x2OlibUpdates :: ([LocalIdentifierBindingsUpdate]) _lhsOannotatedTree :: ExpressionStatementListPair _lhsOoriginalTree :: ExpressionStatementListPair _x1Ocat :: Catalog _x1Olib :: LocalIdentifierBindings _x2Ocat :: Catalog _x2Olib :: LocalIdentifierBindings _x1IannotatedTree :: Expression _x1IliftedColumnName :: String _x1IoriginalTree :: Expression _x2IannotatedTree :: StatementList _x2IoriginalTree :: StatementList _x2IproducedCat :: Catalog _x2IproducedLib :: LocalIdentifierBindings -- "./TypeChecking/Statements.ag"(line 98, column 9) _x2OcatUpdates = {-# LINE 98 "./TypeChecking/Statements.ag" #-} [] {-# LINE 4942 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 99, column 9) _x2OlibUpdates = {-# LINE 99 "./TypeChecking/Statements.ag" #-} [] {-# LINE 4947 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} (_x1IannotatedTree,_x2IannotatedTree) {-# LINE 4952 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} (_x1IoriginalTree,_x2IoriginalTree) {-# LINE 4957 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 4962 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 4967 "AstInternal.hs" #-} -- copy rule (down) _x1Ocat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 4972 "AstInternal.hs" #-} -- copy rule (down) _x1Olib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 4977 "AstInternal.hs" #-} -- copy rule (down) _x2Ocat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 4982 "AstInternal.hs" #-} -- copy rule (down) _x2Olib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 4987 "AstInternal.hs" #-} ( _x1IannotatedTree,_x1IliftedColumnName,_x1IoriginalTree) = (x1_ _x1Ocat _x1Olib ) ( _x2IannotatedTree,_x2IoriginalTree,_x2IproducedCat,_x2IproducedLib) = (x2_ _x2Ocat _x2OcatUpdates _x2Olib _x2OlibUpdates ) in ( _lhsOannotatedTree,_lhsOoriginalTree))) -- ExpressionStatementListPairList ----------------------------- {- visit 0: inherited attributes: cat : Catalog 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 = Catalog -> LocalIdentifierBindings -> ( ExpressionStatementListPairList,ExpressionStatementListPairList) data Inh_ExpressionStatementListPairList = Inh_ExpressionStatementListPairList {cat_Inh_ExpressionStatementListPairList :: Catalog,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 _lhsIcat _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIcat _lhsIlib ) in (Syn_ExpressionStatementListPairList _lhsOannotatedTree _lhsOoriginalTree )) sem_ExpressionStatementListPairList_Cons :: T_ExpressionStatementListPair -> T_ExpressionStatementListPairList -> T_ExpressionStatementListPairList sem_ExpressionStatementListPairList_Cons hd_ tl_ = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: ExpressionStatementListPairList _lhsOoriginalTree :: ExpressionStatementListPairList _hdOcat :: Catalog _hdOlib :: LocalIdentifierBindings _tlOcat :: Catalog _tlOlib :: LocalIdentifierBindings _hdIannotatedTree :: ExpressionStatementListPair _hdIoriginalTree :: ExpressionStatementListPair _tlIannotatedTree :: ExpressionStatementListPairList _tlIoriginalTree :: ExpressionStatementListPairList -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} (:) _hdIannotatedTree _tlIannotatedTree {-# LINE 5053 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} (:) _hdIoriginalTree _tlIoriginalTree {-# LINE 5058 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 5063 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 5068 "AstInternal.hs" #-} -- copy rule (down) _hdOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 5073 "AstInternal.hs" #-} -- copy rule (down) _hdOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 5078 "AstInternal.hs" #-} -- copy rule (down) _tlOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 5083 "AstInternal.hs" #-} -- copy rule (down) _tlOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 5088 "AstInternal.hs" #-} ( _hdIannotatedTree,_hdIoriginalTree) = (hd_ _hdOcat _hdOlib ) ( _tlIannotatedTree,_tlIoriginalTree) = (tl_ _tlOcat _tlOlib ) in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_ExpressionStatementListPairList_Nil :: T_ExpressionStatementListPairList sem_ExpressionStatementListPairList_Nil = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: ExpressionStatementListPairList _lhsOoriginalTree :: ExpressionStatementListPairList -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 5104 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 5109 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 5114 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 5119 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) -- FnBody ------------------------------------------------------ {- visit 0: inherited attributes: cat : Catalog 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 = Catalog -> LocalIdentifierBindings -> ( FnBody,FnBody) data Inh_FnBody = Inh_FnBody {cat_Inh_FnBody :: Catalog,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 _lhsIcat _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIcat _lhsIlib ) in (Syn_FnBody _lhsOannotatedTree _lhsOoriginalTree )) sem_FnBody_PlpgsqlFnBody :: Annotation -> T_VarDefList -> T_StatementList -> T_FnBody sem_FnBody_PlpgsqlFnBody ann_ vars_ sts_ = (\ _lhsIcat _lhsIlib -> (let _stsOcatUpdates :: ([CatalogUpdate]) _stsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _stsOlib :: LocalIdentifierBindings _lhsOannotatedTree :: FnBody _lhsOoriginalTree :: FnBody _varsOcat :: Catalog _varsOlib :: LocalIdentifierBindings _stsOcat :: Catalog _varsIannotatedTree :: VarDefList _varsIdefs :: ([(String,Type)]) _varsIoriginalTree :: VarDefList _stsIannotatedTree :: StatementList _stsIoriginalTree :: StatementList _stsIproducedCat :: Catalog _stsIproducedLib :: LocalIdentifierBindings -- "./TypeChecking/Statements.ag"(line 102, column 9) _stsOcatUpdates = {-# LINE 102 "./TypeChecking/Statements.ag" #-} [] {-# LINE 5194 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 103, column 9) _stsOlibUpdates = {-# LINE 103 "./TypeChecking/Statements.ag" #-} [] {-# LINE 5199 "AstInternal.hs" #-} -- "./TypeChecking/CreateFunction.ag"(line 121, column 9) _stsOlib = {-# LINE 121 "./TypeChecking/CreateFunction.ag" #-} fromRight _lhsIlib $ updateBindings _lhsIlib _lhsIcat [LibStackIDs [("", _varsIdefs)]] {-# LINE 5206 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} PlpgsqlFnBody ann_ _varsIannotatedTree _stsIannotatedTree {-# LINE 5211 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} PlpgsqlFnBody ann_ _varsIoriginalTree _stsIoriginalTree {-# LINE 5216 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 5221 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 5226 "AstInternal.hs" #-} -- copy rule (down) _varsOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 5231 "AstInternal.hs" #-} -- copy rule (down) _varsOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 5236 "AstInternal.hs" #-} -- copy rule (down) _stsOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 5241 "AstInternal.hs" #-} ( _varsIannotatedTree,_varsIdefs,_varsIoriginalTree) = (vars_ _varsOcat _varsOlib ) ( _stsIannotatedTree,_stsIoriginalTree,_stsIproducedCat,_stsIproducedLib) = (sts_ _stsOcat _stsOcatUpdates _stsOlib _stsOlibUpdates ) in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_FnBody_SqlFnBody :: Annotation -> T_StatementList -> T_FnBody sem_FnBody_SqlFnBody ann_ sts_ = (\ _lhsIcat _lhsIlib -> (let _stsOcatUpdates :: ([CatalogUpdate]) _stsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _lhsOannotatedTree :: FnBody _lhsOoriginalTree :: FnBody _stsOcat :: Catalog _stsOlib :: LocalIdentifierBindings _stsIannotatedTree :: StatementList _stsIoriginalTree :: StatementList _stsIproducedCat :: Catalog _stsIproducedLib :: LocalIdentifierBindings -- "./TypeChecking/Statements.ag"(line 102, column 9) _stsOcatUpdates = {-# LINE 102 "./TypeChecking/Statements.ag" #-} [] {-# LINE 5267 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 103, column 9) _stsOlibUpdates = {-# LINE 103 "./TypeChecking/Statements.ag" #-} [] {-# LINE 5272 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} SqlFnBody ann_ _stsIannotatedTree {-# LINE 5277 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} SqlFnBody ann_ _stsIoriginalTree {-# LINE 5282 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 5287 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 5292 "AstInternal.hs" #-} -- copy rule (down) _stsOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 5297 "AstInternal.hs" #-} -- copy rule (down) _stsOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 5302 "AstInternal.hs" #-} ( _stsIannotatedTree,_stsIoriginalTree,_stsIproducedCat,_stsIproducedLib) = (sts_ _stsOcat _stsOcatUpdates _stsOlib _stsOlibUpdates ) in ( _lhsOannotatedTree,_lhsOoriginalTree))) -- FrameClause ------------------------------------------------- {- visit 0: inherited attributes: cat : Catalog 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 = Catalog -> LocalIdentifierBindings -> ( FrameClause,FrameClause) data Inh_FrameClause = Inh_FrameClause {cat_Inh_FrameClause :: Catalog,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 _lhsIcat _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIcat _lhsIlib ) in (Syn_FrameClause _lhsOannotatedTree _lhsOoriginalTree )) sem_FrameClause_FrameRowsUnboundedPreceding :: T_FrameClause sem_FrameClause_FrameRowsUnboundedPreceding = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: FrameClause _lhsOoriginalTree :: FrameClause -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} FrameRowsUnboundedPreceding {-# LINE 5365 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} FrameRowsUnboundedPreceding {-# LINE 5370 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 5375 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 5380 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_FrameClause_FrameUnboundedFull :: T_FrameClause sem_FrameClause_FrameUnboundedFull = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: FrameClause _lhsOoriginalTree :: FrameClause -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} FrameUnboundedFull {-# LINE 5392 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} FrameUnboundedFull {-# LINE 5397 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 5402 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 5407 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_FrameClause_FrameUnboundedPreceding :: T_FrameClause sem_FrameClause_FrameUnboundedPreceding = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: FrameClause _lhsOoriginalTree :: FrameClause -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} FrameUnboundedPreceding {-# LINE 5419 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} FrameUnboundedPreceding {-# LINE 5424 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 5429 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 5434 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) -- IfExists ---------------------------------------------------- {- visit 0: inherited attributes: cat : Catalog 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 = Catalog -> LocalIdentifierBindings -> ( IfExists,IfExists) data Inh_IfExists = Inh_IfExists {cat_Inh_IfExists :: Catalog,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 _lhsIcat _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIcat _lhsIlib ) in (Syn_IfExists _lhsOannotatedTree _lhsOoriginalTree )) sem_IfExists_IfExists :: T_IfExists sem_IfExists_IfExists = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: IfExists _lhsOoriginalTree :: IfExists -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} IfExists {-# LINE 5488 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} IfExists {-# LINE 5493 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 5498 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 5503 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_IfExists_Require :: T_IfExists sem_IfExists_Require = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: IfExists _lhsOoriginalTree :: IfExists -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Require {-# LINE 5515 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Require {-# LINE 5520 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 5525 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 5530 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) -- InList ------------------------------------------------------ {- visit 0: inherited attributes: cat : Catalog 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 = Catalog -> LocalIdentifierBindings -> ( InList,(Either [TypeError] Type),InList) data Inh_InList = Inh_InList {cat_Inh_InList :: Catalog,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 _lhsIcat _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOlistType,_lhsOoriginalTree) = (sem _lhsIcat _lhsIlib ) in (Syn_InList _lhsOannotatedTree _lhsOlistType _lhsOoriginalTree )) sem_InList_InList :: Annotation -> T_ExpressionList -> T_InList sem_InList_InList ann_ exprs_ = (\ _lhsIcat _lhsIlib -> (let _lhsOlistType :: (Either [TypeError] Type) _lhsOannotatedTree :: InList _lhsOoriginalTree :: InList _exprsOcat :: Catalog _exprsOlib :: LocalIdentifierBindings _exprsIannotatedTree :: ExpressionList _exprsIoriginalTree :: ExpressionList _exprsItypeList :: ([Type]) -- "./TypeChecking/Expressions.ag"(line 305, column 9) _lhsOlistType = {-# LINE 305 "./TypeChecking/Expressions.ag" #-} resolveResultSetType _lhsIcat _exprsItypeList {-# LINE 5597 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} InList ann_ _exprsIannotatedTree {-# LINE 5602 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} InList ann_ _exprsIoriginalTree {-# LINE 5607 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 5612 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 5617 "AstInternal.hs" #-} -- copy rule (down) _exprsOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 5622 "AstInternal.hs" #-} -- copy rule (down) _exprsOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 5627 "AstInternal.hs" #-} ( _exprsIannotatedTree,_exprsIoriginalTree,_exprsItypeList) = (exprs_ _exprsOcat _exprsOlib ) in ( _lhsOannotatedTree,_lhsOlistType,_lhsOoriginalTree))) sem_InList_InSelect :: Annotation -> T_SelectExpression -> T_InList sem_InList_InSelect ann_ sel_ = (\ _lhsIcat _lhsIlib -> (let _lhsOlistType :: (Either [TypeError] Type) _lhsOannotatedTree :: InList _lhsOoriginalTree :: InList _selOcat :: Catalog _selOlib :: LocalIdentifierBindings _selIannotatedTree :: SelectExpression _selIlibUpdates :: ([LocalIdentifierBindingsUpdate]) _selIoriginalTree :: SelectExpression -- "./TypeChecking/Expressions.ag"(line 307, column 9) _lhsOlistType = {-# LINE 307 "./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 5657 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} InSelect ann_ _selIannotatedTree {-# LINE 5662 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} InSelect ann_ _selIoriginalTree {-# LINE 5667 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 5672 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 5677 "AstInternal.hs" #-} -- copy rule (down) _selOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 5682 "AstInternal.hs" #-} -- copy rule (down) _selOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 5687 "AstInternal.hs" #-} ( _selIannotatedTree,_selIlibUpdates,_selIoriginalTree) = (sel_ _selOcat _selOlib ) in ( _lhsOannotatedTree,_lhsOlistType,_lhsOoriginalTree))) -- JoinExpression ---------------------------------------------- {- visit 0: inherited attributes: cat : Catalog 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 = Catalog -> LocalIdentifierBindings -> ( JoinExpression,JoinExpression) data Inh_JoinExpression = Inh_JoinExpression {cat_Inh_JoinExpression :: Catalog,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 _lhsIcat _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIcat _lhsIlib ) in (Syn_JoinExpression _lhsOannotatedTree _lhsOoriginalTree )) sem_JoinExpression_JoinOn :: Annotation -> T_Expression -> T_JoinExpression sem_JoinExpression_JoinOn ann_ expression_ = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: JoinExpression _lhsOoriginalTree :: JoinExpression _expressionOcat :: Catalog _expressionOlib :: LocalIdentifierBindings _expressionIannotatedTree :: Expression _expressionIliftedColumnName :: String _expressionIoriginalTree :: Expression -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} JoinOn ann_ _expressionIannotatedTree {-# LINE 5754 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} JoinOn ann_ _expressionIoriginalTree {-# LINE 5759 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 5764 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 5769 "AstInternal.hs" #-} -- copy rule (down) _expressionOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 5774 "AstInternal.hs" #-} -- copy rule (down) _expressionOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 5779 "AstInternal.hs" #-} ( _expressionIannotatedTree,_expressionIliftedColumnName,_expressionIoriginalTree) = (expression_ _expressionOcat _expressionOlib ) in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_JoinExpression_JoinUsing :: Annotation -> T_StringList -> T_JoinExpression sem_JoinExpression_JoinUsing ann_ stringList_ = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: JoinExpression _lhsOoriginalTree :: JoinExpression _stringListOcat :: Catalog _stringListOlib :: LocalIdentifierBindings _stringListIannotatedTree :: StringList _stringListIoriginalTree :: StringList _stringListIstrings :: ([String]) -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} JoinUsing ann_ _stringListIannotatedTree {-# LINE 5800 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} JoinUsing ann_ _stringListIoriginalTree {-# LINE 5805 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 5810 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 5815 "AstInternal.hs" #-} -- copy rule (down) _stringListOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 5820 "AstInternal.hs" #-} -- copy rule (down) _stringListOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 5825 "AstInternal.hs" #-} ( _stringListIannotatedTree,_stringListIoriginalTree,_stringListIstrings) = (stringList_ _stringListOcat _stringListOlib ) in ( _lhsOannotatedTree,_lhsOoriginalTree))) -- JoinType ---------------------------------------------------- {- visit 0: inherited attributes: cat : Catalog 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 = Catalog -> LocalIdentifierBindings -> ( JoinType,JoinType) data Inh_JoinType = Inh_JoinType {cat_Inh_JoinType :: Catalog,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 _lhsIcat _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIcat _lhsIlib ) in (Syn_JoinType _lhsOannotatedTree _lhsOoriginalTree )) sem_JoinType_Cross :: T_JoinType sem_JoinType_Cross = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: JoinType _lhsOoriginalTree :: JoinType -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Cross {-# LINE 5902 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Cross {-# LINE 5907 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 5912 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 5917 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_JoinType_FullOuter :: T_JoinType sem_JoinType_FullOuter = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: JoinType _lhsOoriginalTree :: JoinType -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} FullOuter {-# LINE 5929 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} FullOuter {-# LINE 5934 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 5939 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 5944 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_JoinType_Inner :: T_JoinType sem_JoinType_Inner = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: JoinType _lhsOoriginalTree :: JoinType -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Inner {-# LINE 5956 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Inner {-# LINE 5961 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 5966 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 5971 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_JoinType_LeftOuter :: T_JoinType sem_JoinType_LeftOuter = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: JoinType _lhsOoriginalTree :: JoinType -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} LeftOuter {-# LINE 5983 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} LeftOuter {-# LINE 5988 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 5993 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 5998 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_JoinType_RightOuter :: T_JoinType sem_JoinType_RightOuter = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: JoinType _lhsOoriginalTree :: JoinType -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} RightOuter {-# LINE 6010 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} RightOuter {-# LINE 6015 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 6020 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 6025 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) -- Language ---------------------------------------------------- {- visit 0: inherited attributes: cat : Catalog 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 = Catalog -> LocalIdentifierBindings -> ( Language,Language) data Inh_Language = Inh_Language {cat_Inh_Language :: Catalog,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 _lhsIcat _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIcat _lhsIlib ) in (Syn_Language _lhsOannotatedTree _lhsOoriginalTree )) sem_Language_Plpgsql :: T_Language sem_Language_Plpgsql = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: Language _lhsOoriginalTree :: Language -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Plpgsql {-# LINE 6079 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Plpgsql {-# LINE 6084 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 6089 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 6094 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_Language_Sql :: T_Language sem_Language_Sql = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: Language _lhsOoriginalTree :: Language -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Sql {-# LINE 6106 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Sql {-# LINE 6111 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 6116 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 6121 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) -- LiftFlavour ------------------------------------------------- {- visit 0: inherited attributes: cat : Catalog 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 = Catalog -> LocalIdentifierBindings -> ( LiftFlavour,LiftFlavour) data Inh_LiftFlavour = Inh_LiftFlavour {cat_Inh_LiftFlavour :: Catalog,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 _lhsIcat _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIcat _lhsIlib ) in (Syn_LiftFlavour _lhsOannotatedTree _lhsOoriginalTree )) sem_LiftFlavour_LiftAll :: T_LiftFlavour sem_LiftFlavour_LiftAll = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: LiftFlavour _lhsOoriginalTree :: LiftFlavour -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} LiftAll {-# LINE 6175 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} LiftAll {-# LINE 6180 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 6185 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 6190 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_LiftFlavour_LiftAny :: T_LiftFlavour sem_LiftFlavour_LiftAny = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: LiftFlavour _lhsOoriginalTree :: LiftFlavour -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} LiftAny {-# LINE 6202 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} LiftAny {-# LINE 6207 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 6212 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 6217 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) -- MaybeBoolExpression ----------------------------------------- {- visit 0: inherited attributes: cat : Catalog 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 = Catalog -> LocalIdentifierBindings -> ( MaybeBoolExpression,MaybeBoolExpression) data Inh_MaybeBoolExpression = Inh_MaybeBoolExpression {cat_Inh_MaybeBoolExpression :: Catalog,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 _lhsIcat _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIcat _lhsIlib ) in (Syn_MaybeBoolExpression _lhsOannotatedTree _lhsOoriginalTree )) sem_MaybeBoolExpression_Just :: T_Expression -> T_MaybeBoolExpression sem_MaybeBoolExpression_Just just_ = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: MaybeBoolExpression _lhsOoriginalTree :: MaybeBoolExpression _justOcat :: Catalog _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 6279 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Just _justIannotatedTree {-# LINE 6284 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Just _justIoriginalTree {-# LINE 6289 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 6294 "AstInternal.hs" #-} -- copy rule (down) _justOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 6299 "AstInternal.hs" #-} -- copy rule (down) _justOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 6304 "AstInternal.hs" #-} ( _justIannotatedTree,_justIliftedColumnName,_justIoriginalTree) = (just_ _justOcat _justOlib ) in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_MaybeBoolExpression_Nothing :: T_MaybeBoolExpression sem_MaybeBoolExpression_Nothing = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: MaybeBoolExpression _lhsOoriginalTree :: MaybeBoolExpression -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Nothing {-# LINE 6318 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Nothing {-# LINE 6323 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 6328 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 6333 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) -- MaybeExpression --------------------------------------------- {- visit 0: inherited attributes: cat : Catalog 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 = Catalog -> LocalIdentifierBindings -> ( MaybeExpression,MaybeExpression) data Inh_MaybeExpression = Inh_MaybeExpression {cat_Inh_MaybeExpression :: Catalog,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 _lhsIcat _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIcat _lhsIlib ) in (Syn_MaybeExpression _lhsOannotatedTree _lhsOoriginalTree )) sem_MaybeExpression_Just :: T_Expression -> T_MaybeExpression sem_MaybeExpression_Just just_ = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: MaybeExpression _lhsOoriginalTree :: MaybeExpression _justOcat :: Catalog _justOlib :: LocalIdentifierBindings _justIannotatedTree :: Expression _justIliftedColumnName :: String _justIoriginalTree :: Expression -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Just _justIannotatedTree {-# LINE 6392 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Just _justIoriginalTree {-# LINE 6397 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 6402 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 6407 "AstInternal.hs" #-} -- copy rule (down) _justOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 6412 "AstInternal.hs" #-} -- copy rule (down) _justOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 6417 "AstInternal.hs" #-} ( _justIannotatedTree,_justIliftedColumnName,_justIoriginalTree) = (just_ _justOcat _justOlib ) in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_MaybeExpression_Nothing :: T_MaybeExpression sem_MaybeExpression_Nothing = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: MaybeExpression _lhsOoriginalTree :: MaybeExpression -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Nothing {-# LINE 6431 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Nothing {-# LINE 6436 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 6441 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 6446 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) -- MaybeSelectList --------------------------------------------- {- visit 0: inherited attributes: cat : Catalog 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 = Catalog -> LocalIdentifierBindings -> ( MaybeSelectList,(Maybe [(String,Type)]),MaybeSelectList) data Inh_MaybeSelectList = Inh_MaybeSelectList {cat_Inh_MaybeSelectList :: Catalog,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 _lhsIcat _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOlistType,_lhsOoriginalTree) = (sem _lhsIcat _lhsIlib ) in (Syn_MaybeSelectList _lhsOannotatedTree _lhsOlistType _lhsOoriginalTree )) sem_MaybeSelectList_Just :: T_SelectList -> T_MaybeSelectList sem_MaybeSelectList_Just just_ = (\ _lhsIcat _lhsIlib -> (let _lhsOlistType :: (Maybe [(String,Type)]) _lhsOannotatedTree :: MaybeSelectList _lhsOoriginalTree :: MaybeSelectList _justOcat :: Catalog _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 6508 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Just _justIannotatedTree {-# LINE 6513 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Just _justIoriginalTree {-# LINE 6518 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 6523 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 6528 "AstInternal.hs" #-} -- copy rule (down) _justOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 6533 "AstInternal.hs" #-} -- copy rule (down) _justOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 6538 "AstInternal.hs" #-} ( _justIannotatedTree,_justIlibUpdates,_justIlistType,_justIoriginalTree) = (just_ _justOcat _justOlib ) in ( _lhsOannotatedTree,_lhsOlistType,_lhsOoriginalTree))) sem_MaybeSelectList_Nothing :: T_MaybeSelectList sem_MaybeSelectList_Nothing = (\ _lhsIcat _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 6553 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Nothing {-# LINE 6558 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Nothing {-# LINE 6563 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 6568 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 6573 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOlistType,_lhsOoriginalTree))) -- Natural ----------------------------------------------------- {- visit 0: inherited attributes: cat : Catalog 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 = Catalog -> LocalIdentifierBindings -> ( Natural,Natural) data Inh_Natural = Inh_Natural {cat_Inh_Natural :: Catalog,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 _lhsIcat _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIcat _lhsIlib ) in (Syn_Natural _lhsOannotatedTree _lhsOoriginalTree )) sem_Natural_Natural :: T_Natural sem_Natural_Natural = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: Natural _lhsOoriginalTree :: Natural -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Natural {-# LINE 6627 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Natural {-# LINE 6632 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 6637 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 6642 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_Natural_Unnatural :: T_Natural sem_Natural_Unnatural = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: Natural _lhsOoriginalTree :: Natural -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Unnatural {-# LINE 6654 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Unnatural {-# LINE 6659 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 6664 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 6669 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) -- OnExpr ------------------------------------------------------ {- visit 0: inherited attributes: cat : Catalog 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 = Catalog -> LocalIdentifierBindings -> ( OnExpr,OnExpr) data Inh_OnExpr = Inh_OnExpr {cat_Inh_OnExpr :: Catalog,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 _lhsIcat _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIcat _lhsIlib ) in (Syn_OnExpr _lhsOannotatedTree _lhsOoriginalTree )) sem_OnExpr_Just :: T_JoinExpression -> T_OnExpr sem_OnExpr_Just just_ = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: OnExpr _lhsOoriginalTree :: OnExpr _justOcat :: Catalog _justOlib :: LocalIdentifierBindings _justIannotatedTree :: JoinExpression _justIoriginalTree :: JoinExpression -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Just _justIannotatedTree {-# LINE 6727 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Just _justIoriginalTree {-# LINE 6732 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 6737 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 6742 "AstInternal.hs" #-} -- copy rule (down) _justOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 6747 "AstInternal.hs" #-} -- copy rule (down) _justOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 6752 "AstInternal.hs" #-} ( _justIannotatedTree,_justIoriginalTree) = (just_ _justOcat _justOlib ) in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_OnExpr_Nothing :: T_OnExpr sem_OnExpr_Nothing = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: OnExpr _lhsOoriginalTree :: OnExpr -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Nothing {-# LINE 6766 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Nothing {-# LINE 6771 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 6776 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 6781 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) -- ParamDef ---------------------------------------------------- {- visit 0: inherited attributes: cat : Catalog 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 = Catalog -> LocalIdentifierBindings -> ( ParamDef,Type,ParamDef,String) data Inh_ParamDef = Inh_ParamDef {cat_Inh_ParamDef :: Catalog,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 _lhsIcat _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOnamedType,_lhsOoriginalTree,_lhsOparamName) = (sem _lhsIcat _lhsIlib ) in (Syn_ParamDef _lhsOannotatedTree _lhsOnamedType _lhsOoriginalTree _lhsOparamName )) sem_ParamDef_ParamDef :: Annotation -> String -> T_TypeName -> T_ParamDef sem_ParamDef_ParamDef ann_ name_ typ_ = (\ _lhsIcat _lhsIlib -> (let _lhsOnamedType :: Type _lhsOparamName :: String _lhsOannotatedTree :: ParamDef _lhsOoriginalTree :: ParamDef _typOcat :: Catalog _typOlib :: LocalIdentifierBindings _typIannotatedTree :: TypeName _typInamedType :: Type _typIoriginalTree :: TypeName -- "./TypeChecking/CreateFunction.ag"(line 56, column 9) _lhsOnamedType = {-# LINE 56 "./TypeChecking/CreateFunction.ag" #-} _typInamedType {-# LINE 6852 "AstInternal.hs" #-} -- "./TypeChecking/CreateFunction.ag"(line 58, column 9) _lhsOparamName = {-# LINE 58 "./TypeChecking/CreateFunction.ag" #-} name_ {-# LINE 6857 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} ParamDef ann_ name_ _typIannotatedTree {-# LINE 6862 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} ParamDef ann_ name_ _typIoriginalTree {-# LINE 6867 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 6872 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 6877 "AstInternal.hs" #-} -- copy rule (down) _typOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 6882 "AstInternal.hs" #-} -- copy rule (down) _typOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 6887 "AstInternal.hs" #-} ( _typIannotatedTree,_typInamedType,_typIoriginalTree) = (typ_ _typOcat _typOlib ) in ( _lhsOannotatedTree,_lhsOnamedType,_lhsOoriginalTree,_lhsOparamName))) sem_ParamDef_ParamDefTp :: Annotation -> T_TypeName -> T_ParamDef sem_ParamDef_ParamDefTp ann_ typ_ = (\ _lhsIcat _lhsIlib -> (let _lhsOnamedType :: Type _lhsOparamName :: String _lhsOannotatedTree :: ParamDef _lhsOoriginalTree :: ParamDef _typOcat :: Catalog _typOlib :: LocalIdentifierBindings _typIannotatedTree :: TypeName _typInamedType :: Type _typIoriginalTree :: TypeName -- "./TypeChecking/CreateFunction.ag"(line 56, column 9) _lhsOnamedType = {-# LINE 56 "./TypeChecking/CreateFunction.ag" #-} _typInamedType {-# LINE 6910 "AstInternal.hs" #-} -- "./TypeChecking/CreateFunction.ag"(line 60, column 9) _lhsOparamName = {-# LINE 60 "./TypeChecking/CreateFunction.ag" #-} "" {-# LINE 6915 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} ParamDefTp ann_ _typIannotatedTree {-# LINE 6920 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} ParamDefTp ann_ _typIoriginalTree {-# LINE 6925 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 6930 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 6935 "AstInternal.hs" #-} -- copy rule (down) _typOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 6940 "AstInternal.hs" #-} -- copy rule (down) _typOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 6945 "AstInternal.hs" #-} ( _typIannotatedTree,_typInamedType,_typIoriginalTree) = (typ_ _typOcat _typOlib ) in ( _lhsOannotatedTree,_lhsOnamedType,_lhsOoriginalTree,_lhsOparamName))) -- ParamDefList ------------------------------------------------ {- visit 0: inherited attributes: cat : Catalog 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 = Catalog -> LocalIdentifierBindings -> ( ParamDefList,ParamDefList,([(String, Type)])) data Inh_ParamDefList = Inh_ParamDefList {cat_Inh_ParamDefList :: Catalog,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 _lhsIcat _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree,_lhsOparams) = (sem _lhsIcat _lhsIlib ) in (Syn_ParamDefList _lhsOannotatedTree _lhsOoriginalTree _lhsOparams )) sem_ParamDefList_Cons :: T_ParamDef -> T_ParamDefList -> T_ParamDefList sem_ParamDefList_Cons hd_ tl_ = (\ _lhsIcat _lhsIlib -> (let _lhsOparams :: ([(String, Type)]) _lhsOannotatedTree :: ParamDefList _lhsOoriginalTree :: ParamDefList _hdOcat :: Catalog _hdOlib :: LocalIdentifierBindings _tlOcat :: Catalog _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 7014 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} (:) _hdIannotatedTree _tlIannotatedTree {-# LINE 7019 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} (:) _hdIoriginalTree _tlIoriginalTree {-# LINE 7024 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 7029 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 7034 "AstInternal.hs" #-} -- copy rule (down) _hdOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 7039 "AstInternal.hs" #-} -- copy rule (down) _hdOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 7044 "AstInternal.hs" #-} -- copy rule (down) _tlOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 7049 "AstInternal.hs" #-} -- copy rule (down) _tlOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 7054 "AstInternal.hs" #-} ( _hdIannotatedTree,_hdInamedType,_hdIoriginalTree,_hdIparamName) = (hd_ _hdOcat _hdOlib ) ( _tlIannotatedTree,_tlIoriginalTree,_tlIparams) = (tl_ _tlOcat _tlOlib ) in ( _lhsOannotatedTree,_lhsOoriginalTree,_lhsOparams))) sem_ParamDefList_Nil :: T_ParamDefList sem_ParamDefList_Nil = (\ _lhsIcat _lhsIlib -> (let _lhsOparams :: ([(String, Type)]) _lhsOannotatedTree :: ParamDefList _lhsOoriginalTree :: ParamDefList -- "./TypeChecking/CreateFunction.ag"(line 63, column 12) _lhsOparams = {-# LINE 63 "./TypeChecking/CreateFunction.ag" #-} [] {-# LINE 7071 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 7076 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 7081 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 7086 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 7091 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree,_lhsOparams))) -- RaiseType --------------------------------------------------- {- visit 0: inherited attributes: cat : Catalog 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 = Catalog -> LocalIdentifierBindings -> ( RaiseType,RaiseType) data Inh_RaiseType = Inh_RaiseType {cat_Inh_RaiseType :: Catalog,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 _lhsIcat _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIcat _lhsIlib ) in (Syn_RaiseType _lhsOannotatedTree _lhsOoriginalTree )) sem_RaiseType_RError :: T_RaiseType sem_RaiseType_RError = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: RaiseType _lhsOoriginalTree :: RaiseType -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} RError {-# LINE 7152 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} RError {-# LINE 7157 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 7162 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 7167 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_RaiseType_RException :: T_RaiseType sem_RaiseType_RException = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: RaiseType _lhsOoriginalTree :: RaiseType -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} RException {-# LINE 7179 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} RException {-# LINE 7184 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 7189 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 7194 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_RaiseType_RNotice :: T_RaiseType sem_RaiseType_RNotice = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: RaiseType _lhsOoriginalTree :: RaiseType -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} RNotice {-# LINE 7206 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} RNotice {-# 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" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) -- RestartIdentity --------------------------------------------- {- visit 0: inherited attributes: cat : Catalog 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 = Catalog -> LocalIdentifierBindings -> ( RestartIdentity,RestartIdentity) data Inh_RestartIdentity = Inh_RestartIdentity {cat_Inh_RestartIdentity :: Catalog,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 _lhsIcat _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIcat _lhsIlib ) in (Syn_RestartIdentity _lhsOannotatedTree _lhsOoriginalTree )) sem_RestartIdentity_ContinueIdentity :: T_RestartIdentity sem_RestartIdentity_ContinueIdentity = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: RestartIdentity _lhsOoriginalTree :: RestartIdentity -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} ContinueIdentity {-# LINE 7275 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} ContinueIdentity {-# LINE 7280 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 7285 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 7290 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_RestartIdentity_RestartIdentity :: T_RestartIdentity sem_RestartIdentity_RestartIdentity = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: RestartIdentity _lhsOoriginalTree :: RestartIdentity -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} RestartIdentity {-# LINE 7302 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} RestartIdentity {-# LINE 7307 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 7312 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 7317 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) -- Root -------------------------------------------------------- {- visit 0: inherited attributes: cat : Catalog lib : LocalIdentifierBindings synthesized attributes: annotatedTree : SELF originalTree : SELF producedCat : Catalog 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 = Catalog -> LocalIdentifierBindings -> ( Root,Root,Catalog,LocalIdentifierBindings) data Inh_Root = Inh_Root {cat_Inh_Root :: Catalog,lib_Inh_Root :: LocalIdentifierBindings} data Syn_Root = Syn_Root {annotatedTree_Syn_Root :: Root,originalTree_Syn_Root :: Root,producedCat_Syn_Root :: Catalog,producedLib_Syn_Root :: LocalIdentifierBindings} wrap_Root :: T_Root -> Inh_Root -> Syn_Root wrap_Root sem (Inh_Root _lhsIcat _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree,_lhsOproducedCat,_lhsOproducedLib) = (sem _lhsIcat _lhsIlib ) in (Syn_Root _lhsOannotatedTree _lhsOoriginalTree _lhsOproducedCat _lhsOproducedLib )) sem_Root_Root :: T_StatementList -> T_Root sem_Root_Root statements_ = (\ _lhsIcat _lhsIlib -> (let _statementsOcatUpdates :: ([CatalogUpdate]) _statementsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _lhsOannotatedTree :: Root _lhsOoriginalTree :: Root _lhsOproducedCat :: Catalog _lhsOproducedLib :: LocalIdentifierBindings _statementsOcat :: Catalog _statementsOlib :: LocalIdentifierBindings _statementsIannotatedTree :: StatementList _statementsIoriginalTree :: StatementList _statementsIproducedCat :: Catalog _statementsIproducedLib :: LocalIdentifierBindings -- "./TypeChecking/Statements.ag"(line 80, column 12) _statementsOcatUpdates = {-# LINE 80 "./TypeChecking/Statements.ag" #-} [] {-# LINE 7378 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 81, column 12) _statementsOlibUpdates = {-# LINE 81 "./TypeChecking/Statements.ag" #-} [] {-# LINE 7383 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Root _statementsIannotatedTree {-# LINE 7388 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Root _statementsIoriginalTree {-# LINE 7393 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 7398 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 7403 "AstInternal.hs" #-} -- copy rule (up) _lhsOproducedCat = {-# LINE 27 "./TypeChecking/Statements.ag" #-} _statementsIproducedCat {-# LINE 7408 "AstInternal.hs" #-} -- copy rule (up) _lhsOproducedLib = {-# LINE 28 "./TypeChecking/Statements.ag" #-} _statementsIproducedLib {-# LINE 7413 "AstInternal.hs" #-} -- copy rule (down) _statementsOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 7418 "AstInternal.hs" #-} -- copy rule (down) _statementsOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 7423 "AstInternal.hs" #-} ( _statementsIannotatedTree,_statementsIoriginalTree,_statementsIproducedCat,_statementsIproducedLib) = (statements_ _statementsOcat _statementsOcatUpdates _statementsOlib _statementsOlibUpdates ) in ( _lhsOannotatedTree,_lhsOoriginalTree,_lhsOproducedCat,_lhsOproducedLib))) -- RowConstraint ----------------------------------------------- {- visit 0: inherited attributes: cat : Catalog 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 = Catalog -> LocalIdentifierBindings -> ( RowConstraint,RowConstraint) data Inh_RowConstraint = Inh_RowConstraint {cat_Inh_RowConstraint :: Catalog,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 _lhsIcat _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIcat _lhsIlib ) in (Syn_RowConstraint _lhsOannotatedTree _lhsOoriginalTree )) sem_RowConstraint_NotNullConstraint :: Annotation -> String -> T_RowConstraint sem_RowConstraint_NotNullConstraint ann_ name_ = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: RowConstraint _lhsOoriginalTree :: RowConstraint -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} NotNullConstraint ann_ name_ {-# LINE 7526 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} NotNullConstraint ann_ name_ {-# LINE 7531 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 7536 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 7541 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_RowConstraint_NullConstraint :: Annotation -> String -> T_RowConstraint sem_RowConstraint_NullConstraint ann_ name_ = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: RowConstraint _lhsOoriginalTree :: RowConstraint -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} NullConstraint ann_ name_ {-# LINE 7555 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} NullConstraint ann_ name_ {-# LINE 7560 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 7565 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 7570 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_RowConstraint_RowCheckConstraint :: Annotation -> String -> T_Expression -> T_RowConstraint sem_RowConstraint_RowCheckConstraint ann_ name_ expression_ = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: RowConstraint _lhsOoriginalTree :: RowConstraint _expressionOcat :: Catalog _expressionOlib :: LocalIdentifierBindings _expressionIannotatedTree :: Expression _expressionIliftedColumnName :: String _expressionIoriginalTree :: Expression -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} RowCheckConstraint ann_ name_ _expressionIannotatedTree {-# LINE 7590 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} RowCheckConstraint ann_ name_ _expressionIoriginalTree {-# LINE 7595 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 7600 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 7605 "AstInternal.hs" #-} -- copy rule (down) _expressionOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 7610 "AstInternal.hs" #-} -- copy rule (down) _expressionOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 7615 "AstInternal.hs" #-} ( _expressionIannotatedTree,_expressionIliftedColumnName,_expressionIoriginalTree) = (expression_ _expressionOcat _expressionOlib ) in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_RowConstraint_RowPrimaryKeyConstraint :: Annotation -> String -> T_RowConstraint sem_RowConstraint_RowPrimaryKeyConstraint ann_ name_ = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: RowConstraint _lhsOoriginalTree :: RowConstraint -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} RowPrimaryKeyConstraint ann_ name_ {-# LINE 7631 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} RowPrimaryKeyConstraint ann_ name_ {-# LINE 7636 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 7641 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 7646 "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_ = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: RowConstraint _lhsOoriginalTree :: RowConstraint _onUpdateOcat :: Catalog _onUpdateOlib :: LocalIdentifierBindings _onDeleteOcat :: Catalog _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 7672 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} RowReferenceConstraint ann_ name_ table_ att_ _onUpdateIoriginalTree _onDeleteIoriginalTree {-# LINE 7677 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 7682 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 7687 "AstInternal.hs" #-} -- copy rule (down) _onUpdateOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 7692 "AstInternal.hs" #-} -- copy rule (down) _onUpdateOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 7697 "AstInternal.hs" #-} -- copy rule (down) _onDeleteOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 7702 "AstInternal.hs" #-} -- copy rule (down) _onDeleteOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 7707 "AstInternal.hs" #-} ( _onUpdateIannotatedTree,_onUpdateIoriginalTree) = (onUpdate_ _onUpdateOcat _onUpdateOlib ) ( _onDeleteIannotatedTree,_onDeleteIoriginalTree) = (onDelete_ _onDeleteOcat _onDeleteOlib ) in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_RowConstraint_RowUniqueConstraint :: Annotation -> String -> T_RowConstraint sem_RowConstraint_RowUniqueConstraint ann_ name_ = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: RowConstraint _lhsOoriginalTree :: RowConstraint -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} RowUniqueConstraint ann_ name_ {-# LINE 7725 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} RowUniqueConstraint ann_ name_ {-# LINE 7730 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 7735 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 7740 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) -- RowConstraintList ------------------------------------------- {- visit 0: inherited attributes: cat : Catalog 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 = Catalog -> LocalIdentifierBindings -> ( RowConstraintList,RowConstraintList) data Inh_RowConstraintList = Inh_RowConstraintList {cat_Inh_RowConstraintList :: Catalog,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 _lhsIcat _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIcat _lhsIlib ) in (Syn_RowConstraintList _lhsOannotatedTree _lhsOoriginalTree )) sem_RowConstraintList_Cons :: T_RowConstraint -> T_RowConstraintList -> T_RowConstraintList sem_RowConstraintList_Cons hd_ tl_ = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: RowConstraintList _lhsOoriginalTree :: RowConstraintList _hdOcat :: Catalog _hdOlib :: LocalIdentifierBindings _tlOcat :: Catalog _tlOlib :: LocalIdentifierBindings _hdIannotatedTree :: RowConstraint _hdIoriginalTree :: RowConstraint _tlIannotatedTree :: RowConstraintList _tlIoriginalTree :: RowConstraintList -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} (:) _hdIannotatedTree _tlIannotatedTree {-# LINE 7802 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} (:) _hdIoriginalTree _tlIoriginalTree {-# LINE 7807 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 7812 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 7817 "AstInternal.hs" #-} -- copy rule (down) _hdOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 7822 "AstInternal.hs" #-} -- copy rule (down) _hdOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 7827 "AstInternal.hs" #-} -- copy rule (down) _tlOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 7832 "AstInternal.hs" #-} -- copy rule (down) _tlOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 7837 "AstInternal.hs" #-} ( _hdIannotatedTree,_hdIoriginalTree) = (hd_ _hdOcat _hdOlib ) ( _tlIannotatedTree,_tlIoriginalTree) = (tl_ _tlOcat _tlOlib ) in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_RowConstraintList_Nil :: T_RowConstraintList sem_RowConstraintList_Nil = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: RowConstraintList _lhsOoriginalTree :: RowConstraintList -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 7853 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 7858 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 7863 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 7868 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) -- SelectExpression -------------------------------------------- {- visit 0: inherited attributes: cat : Catalog 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 = Catalog -> LocalIdentifierBindings -> ( SelectExpression,([LocalIdentifierBindingsUpdate]),SelectExpression) data Inh_SelectExpression = Inh_SelectExpression {cat_Inh_SelectExpression :: Catalog,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 _lhsIcat _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOlibUpdates,_lhsOoriginalTree) = (sem _lhsIcat _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_ = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: SelectExpression _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _lhsOoriginalTree :: SelectExpression _ctypeOcat :: Catalog _ctypeOlib :: LocalIdentifierBindings _sel1Ocat :: Catalog _sel1Olib :: LocalIdentifierBindings _sel2Ocat :: Catalog _sel2Olib :: LocalIdentifierBindings _ctypeIannotatedTree :: CombineType _ctypeIoriginalTree :: CombineType _sel1IannotatedTree :: SelectExpression _sel1IlibUpdates :: ([LocalIdentifierBindingsUpdate]) _sel1IoriginalTree :: SelectExpression _sel2IannotatedTree :: SelectExpression _sel2IlibUpdates :: ([LocalIdentifierBindingsUpdate]) _sel2IoriginalTree :: SelectExpression -- "./TypeChecking/SelectStatement.ag"(line 23, column 9) _lhsOannotatedTree = {-# LINE 23 "./TypeChecking/SelectStatement.ag" #-} annTypesAndErrors _backTree (tpeToT _tpe ) (getErrors _tpe ) Nothing {-# LINE 7975 "AstInternal.hs" #-} -- "./TypeChecking/SelectStatement.ag"(line 129, column 9) _tpe = {-# LINE 129 "./TypeChecking/SelectStatement.ag" #-} let sel1t = getTypeAnnotation _sel1IannotatedTree sel2t = getTypeAnnotation _sel2IannotatedTree in dependsOnRTpe [sel1t, sel2t] $ typeCheckCombineSelect _lhsIcat sel1t sel2t {-# LINE 7983 "AstInternal.hs" #-} -- "./TypeChecking/SelectStatement.ag"(line 134, column 9) _backTree = {-# LINE 134 "./TypeChecking/SelectStatement.ag" #-} CombineSelect ann_ _ctypeIannotatedTree _sel1IannotatedTree _sel2IannotatedTree {-# LINE 7990 "AstInternal.hs" #-} -- "./TypeChecking/SelectLists.ag"(line 87, column 11) _lhsOlibUpdates = {-# LINE 87 "./TypeChecking/SelectLists.ag" #-} [] {-# LINE 7995 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} CombineSelect ann_ _ctypeIannotatedTree _sel1IannotatedTree _sel2IannotatedTree {-# LINE 8000 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} CombineSelect ann_ _ctypeIoriginalTree _sel1IoriginalTree _sel2IoriginalTree {-# LINE 8005 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 8010 "AstInternal.hs" #-} -- copy rule (down) _ctypeOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 8015 "AstInternal.hs" #-} -- copy rule (down) _ctypeOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 8020 "AstInternal.hs" #-} -- copy rule (down) _sel1Ocat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 8025 "AstInternal.hs" #-} -- copy rule (down) _sel1Olib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 8030 "AstInternal.hs" #-} -- copy rule (down) _sel2Ocat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 8035 "AstInternal.hs" #-} -- copy rule (down) _sel2Olib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 8040 "AstInternal.hs" #-} ( _ctypeIannotatedTree,_ctypeIoriginalTree) = (ctype_ _ctypeOcat _ctypeOlib ) ( _sel1IannotatedTree,_sel1IlibUpdates,_sel1IoriginalTree) = (sel1_ _sel1Ocat _sel1Olib ) ( _sel2IannotatedTree,_sel2IlibUpdates,_sel2IoriginalTree) = (sel2_ _sel2Ocat _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_ = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: SelectExpression _selSelectListOlib :: LocalIdentifierBindings _selWhereOlib :: LocalIdentifierBindings _selGroupByOlib :: LocalIdentifierBindings _selOrderByOlib :: LocalIdentifierBindings _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _lhsOoriginalTree :: SelectExpression _selDistinctOcat :: Catalog _selDistinctOlib :: LocalIdentifierBindings _selSelectListOcat :: Catalog _selTrefOcat :: Catalog _selTrefOlib :: LocalIdentifierBindings _selWhereOcat :: Catalog _selGroupByOcat :: Catalog _selHavingOcat :: Catalog _selHavingOlib :: LocalIdentifierBindings _selOrderByOcat :: Catalog _selLimitOcat :: Catalog _selLimitOlib :: LocalIdentifierBindings _selOffsetOcat :: Catalog _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 23, column 9) _lhsOannotatedTree = {-# LINE 23 "./TypeChecking/SelectStatement.ag" #-} annTypesAndErrors _backTree (tpeToT _tpe ) (getErrors _tpe ) Nothing {-# LINE 8112 "AstInternal.hs" #-} -- "./TypeChecking/SelectStatement.ag"(line 94, column 10) _newLib = {-# LINE 94 "./TypeChecking/SelectStatement.ag" #-} case updateBindings _lhsIlib _lhsIcat _selTrefIlibUpdates of Left x -> error $ show x Right e -> e {-# LINE 8119 "AstInternal.hs" #-} -- "./TypeChecking/SelectStatement.ag"(line 97, column 10) _selSelectListOlib = {-# LINE 97 "./TypeChecking/SelectStatement.ag" #-} _newLib {-# LINE 8124 "AstInternal.hs" #-} -- "./TypeChecking/SelectStatement.ag"(line 98, column 10) _selWhereOlib = {-# LINE 98 "./TypeChecking/SelectStatement.ag" #-} _newLib {-# LINE 8129 "AstInternal.hs" #-} -- "./TypeChecking/SelectStatement.ag"(line 99, column 10) _selGroupByOlib = {-# LINE 99 "./TypeChecking/SelectStatement.ag" #-} _newLib {-# LINE 8134 "AstInternal.hs" #-} -- "./TypeChecking/SelectStatement.ag"(line 100, column 10) _selOrderByOlib = {-# LINE 100 "./TypeChecking/SelectStatement.ag" #-} _newLib {-# LINE 8139 "AstInternal.hs" #-} -- "./TypeChecking/SelectStatement.ag"(line 111, column 9) _tpe = {-# LINE 111 "./TypeChecking/SelectStatement.ag" #-} do Right $ case _selSelectListIlistType of [(_,Pseudo Void)] -> Pseudo Void _ -> SetOfType $ CompositeType _selSelectListIlistType {-# LINE 8147 "AstInternal.hs" #-} -- "./TypeChecking/SelectStatement.ag"(line 118, column 9) _backTree = {-# LINE 118 "./TypeChecking/SelectStatement.ag" #-} Select ann_ _selDistinctIannotatedTree _selSelectListIannotatedTree _selTrefIannotatedTree _selWhereIannotatedTree _selGroupByIannotatedTree _selHavingIannotatedTree _selOrderByIannotatedTree _selLimitIannotatedTree _selOffsetIannotatedTree {-# LINE 8161 "AstInternal.hs" #-} -- "./TypeChecking/SelectLists.ag"(line 85, column 9) _lhsOlibUpdates = {-# LINE 85 "./TypeChecking/SelectLists.ag" #-} _selSelectListIlibUpdates {-# LINE 8166 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Select ann_ _selDistinctIannotatedTree _selSelectListIannotatedTree _selTrefIannotatedTree _selWhereIannotatedTree _selGroupByIannotatedTree _selHavingIannotatedTree _selOrderByIannotatedTree _selLimitIannotatedTree _selOffsetIannotatedTree {-# LINE 8171 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Select ann_ _selDistinctIoriginalTree _selSelectListIoriginalTree _selTrefIoriginalTree _selWhereIoriginalTree _selGroupByIoriginalTree _selHavingIoriginalTree _selOrderByIoriginalTree _selLimitIoriginalTree _selOffsetIoriginalTree {-# LINE 8176 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 8181 "AstInternal.hs" #-} -- copy rule (down) _selDistinctOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 8186 "AstInternal.hs" #-} -- copy rule (down) _selDistinctOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 8191 "AstInternal.hs" #-} -- copy rule (down) _selSelectListOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 8196 "AstInternal.hs" #-} -- copy rule (down) _selTrefOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 8201 "AstInternal.hs" #-} -- copy rule (down) _selTrefOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 8206 "AstInternal.hs" #-} -- copy rule (down) _selWhereOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 8211 "AstInternal.hs" #-} -- copy rule (down) _selGroupByOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 8216 "AstInternal.hs" #-} -- copy rule (down) _selHavingOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 8221 "AstInternal.hs" #-} -- copy rule (down) _selHavingOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 8226 "AstInternal.hs" #-} -- copy rule (down) _selOrderByOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 8231 "AstInternal.hs" #-} -- copy rule (down) _selLimitOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 8236 "AstInternal.hs" #-} -- copy rule (down) _selLimitOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 8241 "AstInternal.hs" #-} -- copy rule (down) _selOffsetOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 8246 "AstInternal.hs" #-} -- copy rule (down) _selOffsetOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 8251 "AstInternal.hs" #-} ( _selDistinctIannotatedTree,_selDistinctIoriginalTree) = (selDistinct_ _selDistinctOcat _selDistinctOlib ) ( _selSelectListIannotatedTree,_selSelectListIlibUpdates,_selSelectListIlistType,_selSelectListIoriginalTree) = (selSelectList_ _selSelectListOcat _selSelectListOlib ) ( _selTrefIannotatedTree,_selTrefIlibUpdates,_selTrefIoriginalTree) = (selTref_ _selTrefOcat _selTrefOlib ) ( _selWhereIannotatedTree,_selWhereIoriginalTree) = (selWhere_ _selWhereOcat _selWhereOlib ) ( _selGroupByIannotatedTree,_selGroupByIoriginalTree,_selGroupByItypeList) = (selGroupBy_ _selGroupByOcat _selGroupByOlib ) ( _selHavingIannotatedTree,_selHavingIoriginalTree) = (selHaving_ _selHavingOcat _selHavingOlib ) ( _selOrderByIannotatedTree,_selOrderByIoriginalTree) = (selOrderBy_ _selOrderByOcat _selOrderByOlib ) ( _selLimitIannotatedTree,_selLimitIoriginalTree) = (selLimit_ _selLimitOcat _selLimitOlib ) ( _selOffsetIannotatedTree,_selOffsetIoriginalTree) = (selOffset_ _selOffsetOcat _selOffsetOlib ) in ( _lhsOannotatedTree,_lhsOlibUpdates,_lhsOoriginalTree))) sem_SelectExpression_Values :: Annotation -> T_ExpressionListList -> T_SelectExpression sem_SelectExpression_Values ann_ vll_ = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: SelectExpression _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _lhsOoriginalTree :: SelectExpression _vllOcat :: Catalog _vllOlib :: LocalIdentifierBindings _vllIannotatedTree :: ExpressionListList _vllIoriginalTree :: ExpressionListList _vllItypeListList :: ([[Type]]) -- "./TypeChecking/SelectStatement.ag"(line 23, column 9) _lhsOannotatedTree = {-# LINE 23 "./TypeChecking/SelectStatement.ag" #-} annTypesAndErrors _backTree (tpeToT _tpe ) (getErrors _tpe ) Nothing {-# LINE 8292 "AstInternal.hs" #-} -- "./TypeChecking/SelectStatement.ag"(line 106, column 9) _tpe = {-# LINE 106 "./TypeChecking/SelectStatement.ag" #-} typeCheckValuesExpr _lhsIcat _vllItypeListList {-# LINE 8299 "AstInternal.hs" #-} -- "./TypeChecking/SelectStatement.ag"(line 109, column 9) _backTree = {-# LINE 109 "./TypeChecking/SelectStatement.ag" #-} Values ann_ _vllIannotatedTree {-# LINE 8304 "AstInternal.hs" #-} -- "./TypeChecking/SelectLists.ag"(line 87, column 11) _lhsOlibUpdates = {-# LINE 87 "./TypeChecking/SelectLists.ag" #-} [] {-# LINE 8309 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Values ann_ _vllIannotatedTree {-# LINE 8314 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Values ann_ _vllIoriginalTree {-# LINE 8319 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 8324 "AstInternal.hs" #-} -- copy rule (down) _vllOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 8329 "AstInternal.hs" #-} -- copy rule (down) _vllOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 8334 "AstInternal.hs" #-} ( _vllIannotatedTree,_vllIoriginalTree,_vllItypeListList) = (vll_ _vllOcat _vllOlib ) in ( _lhsOannotatedTree,_lhsOlibUpdates,_lhsOoriginalTree))) -- SelectItem -------------------------------------------------- {- visit 0: inherited attributes: cat : Catalog 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 = Catalog -> LocalIdentifierBindings -> ( SelectItem,String,Type,SelectItem) data Inh_SelectItem = Inh_SelectItem {cat_Inh_SelectItem :: Catalog,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 _lhsIcat _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOcolumnName,_lhsOitemType,_lhsOoriginalTree) = (sem _lhsIcat _lhsIlib ) in (Syn_SelectItem _lhsOannotatedTree _lhsOcolumnName _lhsOitemType _lhsOoriginalTree )) sem_SelectItem_SelExp :: Annotation -> T_Expression -> T_SelectItem sem_SelectItem_SelExp ann_ ex_ = (\ _lhsIcat _lhsIlib -> (let _lhsOitemType :: Type _lhsOcolumnName :: String _lhsOannotatedTree :: SelectItem _lhsOoriginalTree :: SelectItem _exOcat :: Catalog _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 8406 "AstInternal.hs" #-} -- "./TypeChecking/SelectLists.ag"(line 35, column 9) _lhsOitemType = {-# LINE 35 "./TypeChecking/SelectLists.ag" #-} getTypeAnnotation _exIannotatedTree {-# LINE 8411 "AstInternal.hs" #-} -- "./TypeChecking/SelectLists.ag"(line 181, column 14) _lhsOcolumnName = {-# LINE 181 "./TypeChecking/SelectLists.ag" #-} case _exIliftedColumnName of "" -> "?column?" s -> s {-# LINE 8418 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} SelExp ann_ _exIoriginalTree {-# LINE 8423 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 8428 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 8433 "AstInternal.hs" #-} -- copy rule (down) _exOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 8438 "AstInternal.hs" #-} -- copy rule (down) _exOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 8443 "AstInternal.hs" #-} ( _exIannotatedTree,_exIliftedColumnName,_exIoriginalTree) = (ex_ _exOcat _exOlib ) in ( _lhsOannotatedTree,_lhsOcolumnName,_lhsOitemType,_lhsOoriginalTree))) sem_SelectItem_SelectItem :: Annotation -> T_Expression -> String -> T_SelectItem sem_SelectItem_SelectItem ann_ ex_ name_ = (\ _lhsIcat _lhsIlib -> (let _lhsOitemType :: Type _lhsOcolumnName :: String _lhsOannotatedTree :: SelectItem _lhsOoriginalTree :: SelectItem _exOcat :: Catalog _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 8467 "AstInternal.hs" #-} -- "./TypeChecking/SelectLists.ag"(line 35, column 9) _lhsOitemType = {-# LINE 35 "./TypeChecking/SelectLists.ag" #-} getTypeAnnotation _exIannotatedTree {-# LINE 8472 "AstInternal.hs" #-} -- "./TypeChecking/SelectLists.ag"(line 184, column 18) _lhsOcolumnName = {-# LINE 184 "./TypeChecking/SelectLists.ag" #-} name_ {-# LINE 8477 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} SelectItem ann_ _exIoriginalTree name_ {-# LINE 8482 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 8487 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 8492 "AstInternal.hs" #-} -- copy rule (down) _exOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 8497 "AstInternal.hs" #-} -- copy rule (down) _exOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 8502 "AstInternal.hs" #-} ( _exIannotatedTree,_exIliftedColumnName,_exIoriginalTree) = (ex_ _exOcat _exOlib ) in ( _lhsOannotatedTree,_lhsOcolumnName,_lhsOitemType,_lhsOoriginalTree))) -- SelectItemList ---------------------------------------------- {- visit 0: inherited attributes: cat : Catalog 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 = Catalog -> LocalIdentifierBindings -> ( SelectItemList,([(String,Type)]),SelectItemList) data Inh_SelectItemList = Inh_SelectItemList {cat_Inh_SelectItemList :: Catalog,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 _lhsIcat _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOlistType,_lhsOoriginalTree) = (sem _lhsIcat _lhsIlib ) in (Syn_SelectItemList _lhsOannotatedTree _lhsOlistType _lhsOoriginalTree )) sem_SelectItemList_Cons :: T_SelectItem -> T_SelectItemList -> T_SelectItemList sem_SelectItemList_Cons hd_ tl_ = (\ _lhsIcat _lhsIlib -> (let _lhsOlistType :: ([(String,Type)]) _lhsOannotatedTree :: SelectItemList _lhsOoriginalTree :: SelectItemList _hdOcat :: Catalog _hdOlib :: LocalIdentifierBindings _tlOcat :: Catalog _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 8571 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} (:) _hdIannotatedTree _tlIannotatedTree {-# LINE 8576 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} (:) _hdIoriginalTree _tlIoriginalTree {-# LINE 8581 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 8586 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 8591 "AstInternal.hs" #-} -- copy rule (down) _hdOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 8596 "AstInternal.hs" #-} -- copy rule (down) _hdOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 8601 "AstInternal.hs" #-} -- copy rule (down) _tlOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 8606 "AstInternal.hs" #-} -- copy rule (down) _tlOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 8611 "AstInternal.hs" #-} ( _hdIannotatedTree,_hdIcolumnName,_hdIitemType,_hdIoriginalTree) = (hd_ _hdOcat _hdOlib ) ( _tlIannotatedTree,_tlIlistType,_tlIoriginalTree) = (tl_ _tlOcat _tlOlib ) in ( _lhsOannotatedTree,_lhsOlistType,_lhsOoriginalTree))) sem_SelectItemList_Nil :: T_SelectItemList sem_SelectItemList_Nil = (\ _lhsIcat _lhsIlib -> (let _lhsOlistType :: ([(String,Type)]) _lhsOannotatedTree :: SelectItemList _lhsOoriginalTree :: SelectItemList -- "./TypeChecking/SelectLists.ag"(line 30, column 11) _lhsOlistType = {-# LINE 30 "./TypeChecking/SelectLists.ag" #-} [] {-# LINE 8628 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 8633 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 8638 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 8643 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 8648 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOlistType,_lhsOoriginalTree))) -- SelectList -------------------------------------------------- {- visit 0: inherited attributes: cat : Catalog 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 = Catalog -> LocalIdentifierBindings -> ( SelectList,([LocalIdentifierBindingsUpdate]),([(String,Type)]),SelectList) data Inh_SelectList = Inh_SelectList {cat_Inh_SelectList :: Catalog,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 _lhsIcat _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOlibUpdates,_lhsOlistType,_lhsOoriginalTree) = (sem _lhsIcat _lhsIlib ) in (Syn_SelectList _lhsOannotatedTree _lhsOlibUpdates _lhsOlistType _lhsOoriginalTree )) sem_SelectList_SelectList :: Annotation -> T_SelectItemList -> T_StringList -> T_SelectList sem_SelectList_SelectList ann_ items_ into_ = (\ _lhsIcat _lhsIlib -> (let _lhsOlistType :: ([(String,Type)]) _lhsOannotatedTree :: SelectList _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _lhsOoriginalTree :: SelectList _itemsOcat :: Catalog _itemsOlib :: LocalIdentifierBindings _intoOcat :: Catalog _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 8717 "AstInternal.hs" #-} -- "./TypeChecking/SelectLists.ag"(line 43, column 9) _errs = {-# LINE 43 "./TypeChecking/SelectLists.ag" #-} case _stuff of (er,_) -> er {-# LINE 8723 "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 _lhsIcat) typePairs sl = _intoIstrings matchingComposite = case targetTypes of [t] | isCompositeType t -> checkAssignmentValid _lhsIcat (AnonymousRecordType (map snd _itemsIlistType)) t _ -> Left [] {-# LINE 8748 "AstInternal.hs" #-} -- "./TypeChecking/SelectLists.ag"(line 68, column 9) _lhsOannotatedTree = {-# LINE 68 "./TypeChecking/SelectLists.ag" #-} SelectList (ann_ ++ map TypeErrorA _errs ) _itemsIannotatedTree _intoIannotatedTree {-# LINE 8755 "AstInternal.hs" #-} -- "./TypeChecking/SelectLists.ag"(line 71, column 9) _lhsOlibUpdates = {-# LINE 71 "./TypeChecking/SelectLists.ag" #-} case _stuff of (_,Just r) -> [LibStackIDs [("", [r])]] _ -> [] {-# LINE 8762 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} SelectList ann_ _itemsIannotatedTree _intoIannotatedTree {-# LINE 8767 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} SelectList ann_ _itemsIoriginalTree _intoIoriginalTree {-# LINE 8772 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 8777 "AstInternal.hs" #-} -- copy rule (down) _itemsOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 8782 "AstInternal.hs" #-} -- copy rule (down) _itemsOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 8787 "AstInternal.hs" #-} -- copy rule (down) _intoOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 8792 "AstInternal.hs" #-} -- copy rule (down) _intoOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 8797 "AstInternal.hs" #-} ( _itemsIannotatedTree,_itemsIlistType,_itemsIoriginalTree) = (items_ _itemsOcat _itemsOlib ) ( _intoIannotatedTree,_intoIoriginalTree,_intoIstrings) = (into_ _intoOcat _intoOlib ) in ( _lhsOannotatedTree,_lhsOlibUpdates,_lhsOlistType,_lhsOoriginalTree))) -- SetClause --------------------------------------------------- {- visit 0: inherited attributes: cat : Catalog 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 = Catalog -> LocalIdentifierBindings -> ( SetClause,SetClause,([(String,Type)]),(Maybe TypeError)) data Inh_SetClause = Inh_SetClause {cat_Inh_SetClause :: Catalog,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 _lhsIcat _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree,_lhsOpairs,_lhsOrowSetError) = (sem _lhsIcat _lhsIlib ) in (Syn_SetClause _lhsOannotatedTree _lhsOoriginalTree _lhsOpairs _lhsOrowSetError )) sem_SetClause_RowSetClause :: Annotation -> T_StringList -> T_ExpressionList -> T_SetClause sem_SetClause_RowSetClause ann_ atts_ vals_ = (\ _lhsIcat _lhsIlib -> (let _lhsOpairs :: ([(String,Type)]) _lhsOannotatedTree :: SetClause _lhsOoriginalTree :: SetClause _lhsOrowSetError :: (Maybe TypeError) _attsOcat :: Catalog _attsOlib :: LocalIdentifierBindings _valsOcat :: Catalog _valsOlib :: LocalIdentifierBindings _attsIannotatedTree :: StringList _attsIoriginalTree :: StringList _attsIstrings :: ([String]) _valsIannotatedTree :: ExpressionList _valsIoriginalTree :: ExpressionList _valsItypeList :: ([Type]) -- "./TypeChecking/Dml.ag"(line 155, column 9) _rowSetError = {-# LINE 155 "./TypeChecking/Dml.ag" #-} let atts = _attsIstrings types = getRowTypes _valsItypeList in if length atts /= length types then Just WrongNumberOfColumns else Nothing {-# LINE 8883 "AstInternal.hs" #-} -- "./TypeChecking/Dml.ag"(line 161, column 9) _lhsOpairs = {-# LINE 161 "./TypeChecking/Dml.ag" #-} zip _attsIstrings $ getRowTypes _valsItypeList {-# LINE 8888 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} RowSetClause ann_ _attsIannotatedTree _valsIannotatedTree {-# LINE 8893 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} RowSetClause ann_ _attsIoriginalTree _valsIoriginalTree {-# LINE 8898 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 8903 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 8908 "AstInternal.hs" #-} -- copy rule (from local) _lhsOrowSetError = {-# LINE 148 "./TypeChecking/Dml.ag" #-} _rowSetError {-# LINE 8913 "AstInternal.hs" #-} -- copy rule (down) _attsOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 8918 "AstInternal.hs" #-} -- copy rule (down) _attsOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 8923 "AstInternal.hs" #-} -- copy rule (down) _valsOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 8928 "AstInternal.hs" #-} -- copy rule (down) _valsOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 8933 "AstInternal.hs" #-} ( _attsIannotatedTree,_attsIoriginalTree,_attsIstrings) = (atts_ _attsOcat _attsOlib ) ( _valsIannotatedTree,_valsIoriginalTree,_valsItypeList) = (vals_ _valsOcat _valsOlib ) in ( _lhsOannotatedTree,_lhsOoriginalTree,_lhsOpairs,_lhsOrowSetError))) sem_SetClause_SetClause :: Annotation -> String -> T_Expression -> T_SetClause sem_SetClause_SetClause ann_ att_ val_ = (\ _lhsIcat _lhsIlib -> (let _lhsOpairs :: ([(String,Type)]) _lhsOrowSetError :: (Maybe TypeError) _lhsOannotatedTree :: SetClause _lhsOoriginalTree :: SetClause _valOcat :: Catalog _valOlib :: LocalIdentifierBindings _valIannotatedTree :: Expression _valIliftedColumnName :: String _valIoriginalTree :: Expression -- "./TypeChecking/Dml.ag"(line 152, column 9) _lhsOpairs = {-# LINE 152 "./TypeChecking/Dml.ag" #-} [(att_, getTypeAnnotation _valIannotatedTree)] {-# LINE 8959 "AstInternal.hs" #-} -- "./TypeChecking/Dml.ag"(line 153, column 9) _lhsOrowSetError = {-# LINE 153 "./TypeChecking/Dml.ag" #-} Nothing {-# LINE 8964 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} SetClause ann_ att_ _valIannotatedTree {-# LINE 8969 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} SetClause ann_ att_ _valIoriginalTree {-# LINE 8974 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 8979 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 8984 "AstInternal.hs" #-} -- copy rule (down) _valOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 8989 "AstInternal.hs" #-} -- copy rule (down) _valOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 8994 "AstInternal.hs" #-} ( _valIannotatedTree,_valIliftedColumnName,_valIoriginalTree) = (val_ _valOcat _valOlib ) in ( _lhsOannotatedTree,_lhsOoriginalTree,_lhsOpairs,_lhsOrowSetError))) -- SetClauseList ----------------------------------------------- {- visit 0: inherited attributes: cat : Catalog 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 = Catalog -> LocalIdentifierBindings -> ( SetClauseList,SetClauseList,([(String,Type)]),([TypeError])) data Inh_SetClauseList = Inh_SetClauseList {cat_Inh_SetClauseList :: Catalog,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 _lhsIcat _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree,_lhsOpairs,_lhsOrowSetErrors) = (sem _lhsIcat _lhsIlib ) in (Syn_SetClauseList _lhsOannotatedTree _lhsOoriginalTree _lhsOpairs _lhsOrowSetErrors )) sem_SetClauseList_Cons :: T_SetClause -> T_SetClauseList -> T_SetClauseList sem_SetClauseList_Cons hd_ tl_ = (\ _lhsIcat _lhsIlib -> (let _lhsOpairs :: ([(String,Type)]) _lhsOrowSetErrors :: ([TypeError]) _lhsOannotatedTree :: SetClauseList _lhsOoriginalTree :: SetClauseList _hdOcat :: Catalog _hdOlib :: LocalIdentifierBindings _tlOcat :: Catalog _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 142, column 10) _lhsOpairs = {-# LINE 142 "./TypeChecking/Dml.ag" #-} _hdIpairs ++ _tlIpairs {-# LINE 9066 "AstInternal.hs" #-} -- "./TypeChecking/Dml.ag"(line 143, column 10) _lhsOrowSetErrors = {-# LINE 143 "./TypeChecking/Dml.ag" #-} maybeToList _hdIrowSetError ++ _tlIrowSetErrors {-# LINE 9071 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} (:) _hdIannotatedTree _tlIannotatedTree {-# LINE 9076 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} (:) _hdIoriginalTree _tlIoriginalTree {-# LINE 9081 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 9086 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 9091 "AstInternal.hs" #-} -- copy rule (down) _hdOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 9096 "AstInternal.hs" #-} -- copy rule (down) _hdOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 9101 "AstInternal.hs" #-} -- copy rule (down) _tlOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 9106 "AstInternal.hs" #-} -- copy rule (down) _tlOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 9111 "AstInternal.hs" #-} ( _hdIannotatedTree,_hdIoriginalTree,_hdIpairs,_hdIrowSetError) = (hd_ _hdOcat _hdOlib ) ( _tlIannotatedTree,_tlIoriginalTree,_tlIpairs,_tlIrowSetErrors) = (tl_ _tlOcat _tlOlib ) in ( _lhsOannotatedTree,_lhsOoriginalTree,_lhsOpairs,_lhsOrowSetErrors))) sem_SetClauseList_Nil :: T_SetClauseList sem_SetClauseList_Nil = (\ _lhsIcat _lhsIlib -> (let _lhsOpairs :: ([(String,Type)]) _lhsOrowSetErrors :: ([TypeError]) _lhsOannotatedTree :: SetClauseList _lhsOoriginalTree :: SetClauseList -- "./TypeChecking/Dml.ag"(line 144, column 9) _lhsOpairs = {-# LINE 144 "./TypeChecking/Dml.ag" #-} [] {-# LINE 9129 "AstInternal.hs" #-} -- "./TypeChecking/Dml.ag"(line 145, column 9) _lhsOrowSetErrors = {-# LINE 145 "./TypeChecking/Dml.ag" #-} [] {-# LINE 9134 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 9139 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 9144 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 9149 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 9154 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree,_lhsOpairs,_lhsOrowSetErrors))) -- SetValue ---------------------------------------------------- {- visit 0: inherited attributes: cat : Catalog 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 = Catalog -> LocalIdentifierBindings -> ( SetValue,SetValue) data Inh_SetValue = Inh_SetValue {cat_Inh_SetValue :: Catalog,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 _lhsIcat _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIcat _lhsIlib ) in (Syn_SetValue _lhsOannotatedTree _lhsOoriginalTree )) sem_SetValue_SetId :: Annotation -> String -> T_SetValue sem_SetValue_SetId ann_ string_ = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: SetValue _lhsOoriginalTree :: SetValue -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} SetId ann_ string_ {-# LINE 9223 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} SetId ann_ string_ {-# LINE 9228 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 9233 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 9238 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_SetValue_SetNum :: Annotation -> Double -> T_SetValue sem_SetValue_SetNum ann_ double_ = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: SetValue _lhsOoriginalTree :: SetValue -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} SetNum ann_ double_ {-# LINE 9252 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} SetNum ann_ double_ {-# LINE 9257 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 9262 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 9267 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_SetValue_SetStr :: Annotation -> String -> T_SetValue sem_SetValue_SetStr ann_ string_ = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: SetValue _lhsOoriginalTree :: SetValue -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} SetStr ann_ string_ {-# LINE 9281 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} SetStr ann_ string_ {-# LINE 9286 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 9291 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 9296 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) -- Statement --------------------------------------------------- {- visit 0: inherited attributes: cat : Catalog inProducedCat : Catalog lib : LocalIdentifierBindings synthesized attributes: annotatedTree : SELF catUpdates : [CatalogUpdate] 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 catUpdates : {[CatalogUpdate]} 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 catUpdates : {[CatalogUpdate]} 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 catUpdates : {[CatalogUpdate]} local parameterTypes : _ local backTree : _ local statementType : _ local annotatedTree : _ local originalTree : _ alternative CreateLanguage: child ann : {Annotation} child name : {String} visit 0: local libUpdates : _ local tpe : {Either [TypeError] Type} local backTree : _ local statementType : _ local catUpdates : {[CatalogUpdate]} 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 catUpdates : {[CatalogUpdate]} 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 catUpdates : {[CatalogUpdate]} 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 catUpdates : {[CatalogUpdate]} 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 catUpdates : {[CatalogUpdate]} 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 catUpdates : {[CatalogUpdate]} 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 catUpdates : {[CatalogUpdate]} 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 catUpdates : {[CatalogUpdate]} 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 catUpdates : {[CatalogUpdate]} 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 insDataAddedInferredTypes : _ local backTree : _ local catUpdates : {[CatalogUpdate]} 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 catUpdates : {[CatalogUpdate]} 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 catUpdates : {[CatalogUpdate]} 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 assignWInferredTypes : {SetClauseList} local backTree : _ local catUpdates : {[CatalogUpdate]} 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 = Catalog -> Catalog -> LocalIdentifierBindings -> ( Statement,([CatalogUpdate]),([LocalIdentifierBindingsUpdate]),Statement) data Inh_Statement = Inh_Statement {cat_Inh_Statement :: Catalog,inProducedCat_Inh_Statement :: Catalog,lib_Inh_Statement :: LocalIdentifierBindings} data Syn_Statement = Syn_Statement {annotatedTree_Syn_Statement :: Statement,catUpdates_Syn_Statement :: [CatalogUpdate],libUpdates_Syn_Statement :: [LocalIdentifierBindingsUpdate],originalTree_Syn_Statement :: Statement} wrap_Statement :: T_Statement -> Inh_Statement -> Syn_Statement wrap_Statement sem (Inh_Statement _lhsIcat _lhsIinProducedCat _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOcatUpdates,_lhsOlibUpdates,_lhsOoriginalTree) = (sem _lhsIcat _lhsIinProducedCat _lhsIlib ) in (Syn_Statement _lhsOannotatedTree _lhsOcatUpdates _lhsOlibUpdates _lhsOoriginalTree )) sem_Statement_AlterSequence :: Annotation -> String -> String -> T_Statement sem_Statement_AlterSequence ann_ name_ ownedBy_ = (\ _lhsIcat _lhsIinProducedCat _lhsIlib -> (let _lhsOcatUpdates :: ([CatalogUpdate]) _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _lhsOannotatedTree :: Statement _lhsOoriginalTree :: Statement -- "./TypeChecking/Statements.ag"(line 73, column 9) _libUpdates = {-# LINE 73 "./TypeChecking/Statements.ag" #-} [] {-# LINE 9832 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 89, column 9) _lhsOcatUpdates = {-# LINE 89 "./TypeChecking/Statements.ag" #-} [] {-# LINE 9837 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 90, column 9) _lhsOlibUpdates = {-# LINE 90 "./TypeChecking/Statements.ag" #-} [] {-# LINE 9842 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} AlterSequence ann_ name_ ownedBy_ {-# LINE 9847 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} AlterSequence ann_ name_ ownedBy_ {-# LINE 9852 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 9857 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 9862 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOcatUpdates,_lhsOlibUpdates,_lhsOoriginalTree))) sem_Statement_AlterTable :: Annotation -> String -> ([AlterTableAction]) -> T_Statement sem_Statement_AlterTable ann_ name_ actions_ = (\ _lhsIcat _lhsIinProducedCat _lhsIlib -> (let _lhsOcatUpdates :: ([CatalogUpdate]) _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _lhsOannotatedTree :: Statement _lhsOoriginalTree :: Statement -- "./TypeChecking/Statements.ag"(line 89, column 9) _lhsOcatUpdates = {-# LINE 89 "./TypeChecking/Statements.ag" #-} [] {-# LINE 9880 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 90, column 9) _lhsOlibUpdates = {-# LINE 90 "./TypeChecking/Statements.ag" #-} [] {-# LINE 9885 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} AlterTable ann_ name_ actions_ {-# LINE 9890 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} AlterTable ann_ name_ actions_ {-# LINE 9895 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 9900 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 9905 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOcatUpdates,_lhsOlibUpdates,_lhsOoriginalTree))) sem_Statement_Assignment :: Annotation -> String -> T_Expression -> T_Statement sem_Statement_Assignment ann_ target_ value_ = (\ _lhsIcat _lhsIinProducedCat _lhsIlib -> (let _lhsOannotatedTree :: Statement _lhsOcatUpdates :: ([CatalogUpdate]) _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _tpe :: (Either [TypeError] Type) _catUpdates :: ([CatalogUpdate]) _lhsOoriginalTree :: Statement _valueOcat :: Catalog _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 ++ [CatUpdates _catUpdates ]) {-# LINE 9934 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 67, column 9) _lhsOcatUpdates = {-# LINE 67 "./TypeChecking/Statements.ag" #-} _catUpdates {-# LINE 9939 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 68, column 9) _lhsOlibUpdates = {-# LINE 68 "./TypeChecking/Statements.ag" #-} _libUpdates {-# LINE 9944 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 73, column 9) _libUpdates = {-# LINE 73 "./TypeChecking/Statements.ag" #-} [] {-# LINE 9949 "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 _lhsIcat fromType toType return $ Pseudo Void {-# LINE 9959 "AstInternal.hs" #-} -- "./TypeChecking/Plpgsql.ag"(line 30, column 9) _backTree = {-# LINE 30 "./TypeChecking/Plpgsql.ag" #-} Assignment ann_ target_ _valueIannotatedTree {-# LINE 9964 "AstInternal.hs" #-} -- "./TypeChecking/Plpgsql.ag"(line 31, column 9) _catUpdates = {-# LINE 31 "./TypeChecking/Plpgsql.ag" #-} [] {-# LINE 9969 "AstInternal.hs" #-} -- "./TypeChecking/Plpgsql.ag"(line 32, column 9) _statementType = {-# LINE 32 "./TypeChecking/Plpgsql.ag" #-} [] {-# LINE 9974 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Assignment ann_ target_ _valueIannotatedTree {-# LINE 9979 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Assignment ann_ target_ _valueIoriginalTree {-# LINE 9984 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 9989 "AstInternal.hs" #-} -- copy rule (down) _valueOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 9994 "AstInternal.hs" #-} -- copy rule (down) _valueOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 9999 "AstInternal.hs" #-} ( _valueIannotatedTree,_valueIliftedColumnName,_valueIoriginalTree) = (value_ _valueOcat _valueOlib ) in ( _lhsOannotatedTree,_lhsOcatUpdates,_lhsOlibUpdates,_lhsOoriginalTree))) sem_Statement_CaseStatement :: Annotation -> T_Expression -> T_ExpressionListStatementListPairList -> T_StatementList -> T_Statement sem_Statement_CaseStatement ann_ val_ cases_ els_ = (\ _lhsIcat _lhsIinProducedCat _lhsIlib -> (let _lhsOcatUpdates :: ([CatalogUpdate]) _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _elsOcatUpdates :: ([CatalogUpdate]) _elsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _lhsOannotatedTree :: Statement _lhsOoriginalTree :: Statement _valOcat :: Catalog _valOlib :: LocalIdentifierBindings _casesOcat :: Catalog _casesOlib :: LocalIdentifierBindings _elsOcat :: Catalog _elsOlib :: LocalIdentifierBindings _valIannotatedTree :: Expression _valIliftedColumnName :: String _valIoriginalTree :: Expression _casesIannotatedTree :: ExpressionListStatementListPairList _casesIoriginalTree :: ExpressionListStatementListPairList _elsIannotatedTree :: StatementList _elsIoriginalTree :: StatementList _elsIproducedCat :: Catalog _elsIproducedLib :: LocalIdentifierBindings -- "./TypeChecking/Statements.ag"(line 89, column 9) _lhsOcatUpdates = {-# LINE 89 "./TypeChecking/Statements.ag" #-} [] {-# LINE 10037 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 90, column 9) _lhsOlibUpdates = {-# LINE 90 "./TypeChecking/Statements.ag" #-} [] {-# LINE 10042 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 106, column 9) _elsOcatUpdates = {-# LINE 106 "./TypeChecking/Statements.ag" #-} [] {-# LINE 10047 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 107, column 9) _elsOlibUpdates = {-# LINE 107 "./TypeChecking/Statements.ag" #-} [] {-# LINE 10052 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} CaseStatement ann_ _valIannotatedTree _casesIannotatedTree _elsIannotatedTree {-# LINE 10057 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} CaseStatement ann_ _valIoriginalTree _casesIoriginalTree _elsIoriginalTree {-# LINE 10062 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 10067 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 10072 "AstInternal.hs" #-} -- copy rule (down) _valOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 10077 "AstInternal.hs" #-} -- copy rule (down) _valOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 10082 "AstInternal.hs" #-} -- copy rule (down) _casesOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 10087 "AstInternal.hs" #-} -- copy rule (down) _casesOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 10092 "AstInternal.hs" #-} -- copy rule (down) _elsOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 10097 "AstInternal.hs" #-} -- copy rule (down) _elsOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 10102 "AstInternal.hs" #-} ( _valIannotatedTree,_valIliftedColumnName,_valIoriginalTree) = (val_ _valOcat _valOlib ) ( _casesIannotatedTree,_casesIoriginalTree) = (cases_ _casesOcat _casesOlib ) ( _elsIannotatedTree,_elsIoriginalTree,_elsIproducedCat,_elsIproducedLib) = (els_ _elsOcat _elsOcatUpdates _elsOlib _elsOlibUpdates ) in ( _lhsOannotatedTree,_lhsOcatUpdates,_lhsOlibUpdates,_lhsOoriginalTree))) sem_Statement_ContinueStatement :: Annotation -> T_Statement sem_Statement_ContinueStatement ann_ = (\ _lhsIcat _lhsIinProducedCat _lhsIlib -> (let _lhsOcatUpdates :: ([CatalogUpdate]) _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _lhsOannotatedTree :: Statement _lhsOoriginalTree :: Statement -- "./TypeChecking/Statements.ag"(line 89, column 9) _lhsOcatUpdates = {-# LINE 89 "./TypeChecking/Statements.ag" #-} [] {-# LINE 10124 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 90, column 9) _lhsOlibUpdates = {-# LINE 90 "./TypeChecking/Statements.ag" #-} [] {-# LINE 10129 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} ContinueStatement ann_ {-# LINE 10134 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} ContinueStatement ann_ {-# LINE 10139 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 10144 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 10149 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOcatUpdates,_lhsOlibUpdates,_lhsOoriginalTree))) sem_Statement_Copy :: Annotation -> String -> T_StringList -> T_CopySource -> T_Statement sem_Statement_Copy ann_ table_ targetCols_ source_ = (\ _lhsIcat _lhsIinProducedCat _lhsIlib -> (let _lhsOcatUpdates :: ([CatalogUpdate]) _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _lhsOannotatedTree :: Statement _lhsOoriginalTree :: Statement _targetColsOcat :: Catalog _targetColsOlib :: LocalIdentifierBindings _sourceOcat :: Catalog _sourceOlib :: LocalIdentifierBindings _targetColsIannotatedTree :: StringList _targetColsIoriginalTree :: StringList _targetColsIstrings :: ([String]) _sourceIannotatedTree :: CopySource _sourceIoriginalTree :: CopySource -- "./TypeChecking/Statements.ag"(line 89, column 9) _lhsOcatUpdates = {-# LINE 89 "./TypeChecking/Statements.ag" #-} [] {-# LINE 10177 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 90, column 9) _lhsOlibUpdates = {-# LINE 90 "./TypeChecking/Statements.ag" #-} [] {-# LINE 10182 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Copy ann_ table_ _targetColsIannotatedTree _sourceIannotatedTree {-# LINE 10187 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Copy ann_ table_ _targetColsIoriginalTree _sourceIoriginalTree {-# LINE 10192 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 10197 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 10202 "AstInternal.hs" #-} -- copy rule (down) _targetColsOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 10207 "AstInternal.hs" #-} -- copy rule (down) _targetColsOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 10212 "AstInternal.hs" #-} -- copy rule (down) _sourceOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 10217 "AstInternal.hs" #-} -- copy rule (down) _sourceOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 10222 "AstInternal.hs" #-} ( _targetColsIannotatedTree,_targetColsIoriginalTree,_targetColsIstrings) = (targetCols_ _targetColsOcat _targetColsOlib ) ( _sourceIannotatedTree,_sourceIoriginalTree) = (source_ _sourceOcat _sourceOlib ) in ( _lhsOannotatedTree,_lhsOcatUpdates,_lhsOlibUpdates,_lhsOoriginalTree))) sem_Statement_CopyData :: Annotation -> String -> T_Statement sem_Statement_CopyData ann_ insData_ = (\ _lhsIcat _lhsIinProducedCat _lhsIlib -> (let _lhsOcatUpdates :: ([CatalogUpdate]) _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _lhsOannotatedTree :: Statement _lhsOoriginalTree :: Statement -- "./TypeChecking/Statements.ag"(line 89, column 9) _lhsOcatUpdates = {-# LINE 89 "./TypeChecking/Statements.ag" #-} [] {-# LINE 10243 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 90, column 9) _lhsOlibUpdates = {-# LINE 90 "./TypeChecking/Statements.ag" #-} [] {-# LINE 10248 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} CopyData ann_ insData_ {-# LINE 10253 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} CopyData ann_ insData_ {-# LINE 10258 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 10263 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 10268 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOcatUpdates,_lhsOlibUpdates,_lhsOoriginalTree))) sem_Statement_CreateDomain :: Annotation -> String -> T_TypeName -> String -> T_MaybeBoolExpression -> T_Statement sem_Statement_CreateDomain ann_ name_ typ_ checkName_ check_ = (\ _lhsIcat _lhsIinProducedCat _lhsIlib -> (let _lhsOannotatedTree :: Statement _lhsOcatUpdates :: ([CatalogUpdate]) _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _tpe :: (Either [TypeError] Type) _catUpdates :: ([CatalogUpdate]) _checkOlib :: LocalIdentifierBindings _lhsOoriginalTree :: Statement _typOcat :: Catalog _typOlib :: LocalIdentifierBindings _checkOcat :: Catalog _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 ++ [CatUpdates _catUpdates ]) {-# LINE 10303 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 67, column 9) _lhsOcatUpdates = {-# LINE 67 "./TypeChecking/Statements.ag" #-} _catUpdates {-# LINE 10308 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 68, column 9) _lhsOlibUpdates = {-# LINE 68 "./TypeChecking/Statements.ag" #-} _libUpdates {-# LINE 10313 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 73, column 9) _libUpdates = {-# LINE 73 "./TypeChecking/Statements.ag" #-} [] {-# LINE 10318 "AstInternal.hs" #-} -- "./TypeChecking/MiscCreates.ag"(line 64, column 9) _tpe = {-# LINE 64 "./TypeChecking/MiscCreates.ag" #-} Right $ Pseudo Void {-# LINE 10323 "AstInternal.hs" #-} -- "./TypeChecking/MiscCreates.ag"(line 65, column 9) _backTree = {-# LINE 65 "./TypeChecking/MiscCreates.ag" #-} CreateDomain ann_ name_ _typIannotatedTree checkName_ _checkIannotatedTree {-# LINE 10328 "AstInternal.hs" #-} -- "./TypeChecking/MiscCreates.ag"(line 66, column 9) _statementType = {-# LINE 66 "./TypeChecking/MiscCreates.ag" #-} [] {-# LINE 10333 "AstInternal.hs" #-} -- "./TypeChecking/MiscCreates.ag"(line 67, column 9) _catUpdates = {-# LINE 67 "./TypeChecking/MiscCreates.ag" #-} [CatCreateDomain (DomainType name_) _typInamedType] {-# LINE 10338 "AstInternal.hs" #-} -- "./TypeChecking/MiscCreates.ag"(line 69, column 9) _checkOlib = {-# LINE 69 "./TypeChecking/MiscCreates.ag" #-} fromRight _lhsIlib $ updateBindings _lhsIlib _lhsIcat [LibStackIDs [("", [("value", _typInamedType)])]] {-# LINE 10345 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} CreateDomain ann_ name_ _typIannotatedTree checkName_ _checkIannotatedTree {-# LINE 10350 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} CreateDomain ann_ name_ _typIoriginalTree checkName_ _checkIoriginalTree {-# LINE 10355 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 10360 "AstInternal.hs" #-} -- copy rule (down) _typOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 10365 "AstInternal.hs" #-} -- copy rule (down) _typOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 10370 "AstInternal.hs" #-} -- copy rule (down) _checkOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 10375 "AstInternal.hs" #-} ( _typIannotatedTree,_typInamedType,_typIoriginalTree) = (typ_ _typOcat _typOlib ) ( _checkIannotatedTree,_checkIoriginalTree) = (check_ _checkOcat _checkOlib ) in ( _lhsOannotatedTree,_lhsOcatUpdates,_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_ = (\ _lhsIcat _lhsIinProducedCat _lhsIlib -> (let _lhsOannotatedTree :: Statement _lhsOcatUpdates :: ([CatalogUpdate]) _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _tpe :: (Either [TypeError] Type) _catUpdates :: ([CatalogUpdate]) _bodyOcat :: Catalog _bodyOlib :: LocalIdentifierBindings _lhsOoriginalTree :: Statement _paramsOcat :: Catalog _paramsOlib :: LocalIdentifierBindings _rettypeOcat :: Catalog _rettypeOlib :: LocalIdentifierBindings _langOcat :: Catalog _langOlib :: LocalIdentifierBindings _volOcat :: Catalog _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 ++ [CatUpdates _catUpdates ]) {-# LINE 10430 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 67, column 9) _lhsOcatUpdates = {-# LINE 67 "./TypeChecking/Statements.ag" #-} _catUpdates {-# LINE 10435 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 68, column 9) _lhsOlibUpdates = {-# LINE 68 "./TypeChecking/Statements.ag" #-} _libUpdates {-# LINE 10440 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 73, column 9) _libUpdates = {-# LINE 73 "./TypeChecking/Statements.ag" #-} [] {-# LINE 10445 "AstInternal.hs" #-} -- "./TypeChecking/CreateFunction.ag"(line 23, column 9) _tpe = {-# LINE 23 "./TypeChecking/CreateFunction.ag" #-} dependsOnRTpe (_rettypeInamedType : _parameterTypes ) $ Right $ Pseudo Void {-# LINE 10452 "AstInternal.hs" #-} -- "./TypeChecking/CreateFunction.ag"(line 26, column 9) _catUpdates = {-# LINE 26 "./TypeChecking/CreateFunction.ag" #-} dependsOn [tpeToT _tpe ] [] [CatCreateFunction FunName (map toLower name_) _parameterTypes _rettypeInamedType False] {-# LINE 10462 "AstInternal.hs" #-} -- "./TypeChecking/CreateFunction.ag"(line 32, column 9) _parameterTypes = {-# LINE 32 "./TypeChecking/CreateFunction.ag" #-} (map snd _paramsIparams) {-# LINE 10467 "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 10479 "AstInternal.hs" #-} -- "./TypeChecking/CreateFunction.ag"(line 42, column 9) _statementType = {-# LINE 42 "./TypeChecking/CreateFunction.ag" #-} [] {-# LINE 10484 "AstInternal.hs" #-} -- "./TypeChecking/CreateFunction.ag"(line 43, column 9) _bodyOcat = {-# LINE 43 "./TypeChecking/CreateFunction.ag" #-} _lhsIinProducedCat {-# LINE 10489 "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 _lhsIcat [LibStackIDs [("", p) ,(name_, _paramsIparams)]] where posNames :: [String] posNames = map (\l -> '$':show l) [1..] {-# LINE 10502 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} CreateFunction ann_ name_ _paramsIannotatedTree _rettypeIannotatedTree _langIannotatedTree bodyQuote_ _bodyIannotatedTree _volIannotatedTree {-# LINE 10507 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} CreateFunction ann_ name_ _paramsIoriginalTree _rettypeIoriginalTree _langIoriginalTree bodyQuote_ _bodyIoriginalTree _volIoriginalTree {-# LINE 10512 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 10517 "AstInternal.hs" #-} -- copy rule (down) _paramsOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 10522 "AstInternal.hs" #-} -- copy rule (down) _paramsOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 10527 "AstInternal.hs" #-} -- copy rule (down) _rettypeOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 10532 "AstInternal.hs" #-} -- copy rule (down) _rettypeOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 10537 "AstInternal.hs" #-} -- copy rule (down) _langOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 10542 "AstInternal.hs" #-} -- copy rule (down) _langOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 10547 "AstInternal.hs" #-} -- copy rule (down) _volOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 10552 "AstInternal.hs" #-} -- copy rule (down) _volOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 10557 "AstInternal.hs" #-} ( _paramsIannotatedTree,_paramsIoriginalTree,_paramsIparams) = (params_ _paramsOcat _paramsOlib ) ( _rettypeIannotatedTree,_rettypeInamedType,_rettypeIoriginalTree) = (rettype_ _rettypeOcat _rettypeOlib ) ( _langIannotatedTree,_langIoriginalTree) = (lang_ _langOcat _langOlib ) ( _bodyIannotatedTree,_bodyIoriginalTree) = (body_ _bodyOcat _bodyOlib ) ( _volIannotatedTree,_volIoriginalTree) = (vol_ _volOcat _volOlib ) in ( _lhsOannotatedTree,_lhsOcatUpdates,_lhsOlibUpdates,_lhsOoriginalTree))) sem_Statement_CreateLanguage :: Annotation -> String -> T_Statement sem_Statement_CreateLanguage ann_ name_ = (\ _lhsIcat _lhsIinProducedCat _lhsIlib -> (let _lhsOannotatedTree :: Statement _lhsOcatUpdates :: ([CatalogUpdate]) _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _tpe :: (Either [TypeError] Type) _catUpdates :: ([CatalogUpdate]) _lhsOoriginalTree :: Statement -- "./TypeChecking/Statements.ag"(line 61, column 9) _lhsOannotatedTree = {-# LINE 61 "./TypeChecking/Statements.ag" #-} annTypesAndErrors _backTree (tpeToT _tpe ) (getErrors _tpe ) $ Just (map StatementTypeA _statementType ++ [CatUpdates _catUpdates ]) {-# LINE 10590 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 67, column 9) _lhsOcatUpdates = {-# LINE 67 "./TypeChecking/Statements.ag" #-} _catUpdates {-# LINE 10595 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 68, column 9) _lhsOlibUpdates = {-# LINE 68 "./TypeChecking/Statements.ag" #-} _libUpdates {-# LINE 10600 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 73, column 9) _libUpdates = {-# LINE 73 "./TypeChecking/Statements.ag" #-} [] {-# LINE 10605 "AstInternal.hs" #-} -- "./TypeChecking/MiscCreates.ag"(line 75, column 9) _tpe = {-# LINE 75 "./TypeChecking/MiscCreates.ag" #-} Right $ Pseudo Void {-# LINE 10610 "AstInternal.hs" #-} -- "./TypeChecking/MiscCreates.ag"(line 76, column 9) _backTree = {-# LINE 76 "./TypeChecking/MiscCreates.ag" #-} CreateLanguage ann_ name_ {-# LINE 10615 "AstInternal.hs" #-} -- "./TypeChecking/MiscCreates.ag"(line 77, column 9) _statementType = {-# LINE 77 "./TypeChecking/MiscCreates.ag" #-} [] {-# LINE 10620 "AstInternal.hs" #-} -- "./TypeChecking/MiscCreates.ag"(line 78, column 9) _catUpdates = {-# LINE 78 "./TypeChecking/MiscCreates.ag" #-} [CatCreateFunction FunName "plpgsql_call_handler" [] (Pseudo LanguageHandler) False ,CatCreateFunction FunName "plpgsql_validator" [ScalarType "oid"] (Pseudo Void) False] {-# LINE 10626 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} CreateLanguage ann_ name_ {-# LINE 10631 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} CreateLanguage ann_ name_ {-# LINE 10636 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 10641 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOcatUpdates,_lhsOlibUpdates,_lhsOoriginalTree))) sem_Statement_CreateSequence :: Annotation -> String -> Integer -> Integer -> Integer -> Integer -> Integer -> T_Statement sem_Statement_CreateSequence ann_ name_ incr_ min_ max_ start_ cache_ = (\ _lhsIcat _lhsIinProducedCat _lhsIlib -> (let _lhsOcatUpdates :: ([CatalogUpdate]) _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _lhsOannotatedTree :: Statement _lhsOoriginalTree :: Statement -- "./TypeChecking/Statements.ag"(line 73, column 9) _libUpdates = {-# LINE 73 "./TypeChecking/Statements.ag" #-} [] {-# LINE 10663 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 89, column 9) _lhsOcatUpdates = {-# LINE 89 "./TypeChecking/Statements.ag" #-} [] {-# LINE 10668 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 90, column 9) _lhsOlibUpdates = {-# LINE 90 "./TypeChecking/Statements.ag" #-} [] {-# LINE 10673 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} CreateSequence ann_ name_ incr_ min_ max_ start_ cache_ {-# LINE 10678 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} CreateSequence ann_ name_ incr_ min_ max_ start_ cache_ {-# LINE 10683 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 10688 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 10693 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOcatUpdates,_lhsOlibUpdates,_lhsOoriginalTree))) sem_Statement_CreateTable :: Annotation -> String -> T_AttributeDefList -> T_ConstraintList -> T_Statement sem_Statement_CreateTable ann_ name_ atts_ cons_ = (\ _lhsIcat _lhsIinProducedCat _lhsIlib -> (let _lhsOannotatedTree :: Statement _lhsOcatUpdates :: ([CatalogUpdate]) _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _tpe :: (Either [TypeError] Type) _catUpdates :: ([CatalogUpdate]) _attrTypes :: ([Type]) _consOlib :: LocalIdentifierBindings _lhsOoriginalTree :: Statement _attsOcat :: Catalog _attsOlib :: LocalIdentifierBindings _consOcat :: Catalog _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 ++ [CatUpdates _catUpdates ]) {-# LINE 10728 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 67, column 9) _lhsOcatUpdates = {-# LINE 67 "./TypeChecking/Statements.ag" #-} _catUpdates {-# LINE 10733 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 68, column 9) _lhsOlibUpdates = {-# LINE 68 "./TypeChecking/Statements.ag" #-} _libUpdates {-# LINE 10738 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 73, column 9) _libUpdates = {-# LINE 73 "./TypeChecking/Statements.ag" #-} [] {-# LINE 10743 "AstInternal.hs" #-} -- "./TypeChecking/CreateTable.ag"(line 25, column 9) _tpe = {-# LINE 25 "./TypeChecking/CreateTable.ag" #-} dependsOnRTpe _attrTypes $ Right $ Pseudo Void {-# LINE 10748 "AstInternal.hs" #-} -- "./TypeChecking/CreateTable.ag"(line 26, column 9) _catUpdates = {-# LINE 26 "./TypeChecking/CreateTable.ag" #-} dependsOn _attrTypes [] [CatCreateTable name_ _attsIattrs defaultSystemColumns] {-# LINE 10754 "AstInternal.hs" #-} -- "./TypeChecking/CreateTable.ag"(line 29, column 9) _attrTypes = {-# LINE 29 "./TypeChecking/CreateTable.ag" #-} map snd _attsIattrs {-# LINE 10759 "AstInternal.hs" #-} -- "./TypeChecking/CreateTable.ag"(line 31, column 9) _statementType = {-# LINE 31 "./TypeChecking/CreateTable.ag" #-} [] {-# LINE 10764 "AstInternal.hs" #-} -- "./TypeChecking/CreateTable.ag"(line 32, column 9) _backTree = {-# LINE 32 "./TypeChecking/CreateTable.ag" #-} CreateTable ann_ name_ _attsIannotatedTree _consIannotatedTree {-# LINE 10772 "AstInternal.hs" #-} -- "./TypeChecking/CreateTable.ag"(line 36, column 9) _consOlib = {-# LINE 36 "./TypeChecking/CreateTable.ag" #-} case updateBindings _lhsIlib _lhsIcat [LibStackIDs [("", _attsIattrs)]] of Left x -> error $ show x Right e -> e {-# LINE 10780 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} CreateTable ann_ name_ _attsIannotatedTree _consIannotatedTree {-# LINE 10785 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} CreateTable ann_ name_ _attsIoriginalTree _consIoriginalTree {-# LINE 10790 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 10795 "AstInternal.hs" #-} -- copy rule (down) _attsOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 10800 "AstInternal.hs" #-} -- copy rule (down) _attsOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 10805 "AstInternal.hs" #-} -- copy rule (down) _consOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 10810 "AstInternal.hs" #-} ( _attsIannotatedTree,_attsIattrs,_attsIoriginalTree) = (atts_ _attsOcat _attsOlib ) ( _consIannotatedTree,_consIoriginalTree) = (cons_ _consOcat _consOlib ) in ( _lhsOannotatedTree,_lhsOcatUpdates,_lhsOlibUpdates,_lhsOoriginalTree))) sem_Statement_CreateTableAs :: Annotation -> String -> T_SelectExpression -> T_Statement sem_Statement_CreateTableAs ann_ name_ expr_ = (\ _lhsIcat _lhsIinProducedCat _lhsIlib -> (let _lhsOannotatedTree :: Statement _lhsOcatUpdates :: ([CatalogUpdate]) _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _tpe :: (Either [TypeError] Type) _catUpdates :: ([CatalogUpdate]) _lhsOoriginalTree :: Statement _exprOcat :: Catalog _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 ++ [CatUpdates _catUpdates ]) {-# LINE 10843 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 67, column 9) _lhsOcatUpdates = {-# LINE 67 "./TypeChecking/Statements.ag" #-} _catUpdates {-# LINE 10848 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 68, column 9) _lhsOlibUpdates = {-# LINE 68 "./TypeChecking/Statements.ag" #-} _libUpdates {-# LINE 10853 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 73, column 9) _libUpdates = {-# LINE 73 "./TypeChecking/Statements.ag" #-} [] {-# LINE 10858 "AstInternal.hs" #-} -- "./TypeChecking/CreateTable.ag"(line 53, column 9) _tpe = {-# LINE 53 "./TypeChecking/CreateTable.ag" #-} dependsOnRTpe [_selType ] $ do _attrs Right _selType {-# LINE 10865 "AstInternal.hs" #-} -- "./TypeChecking/CreateTable.ag"(line 57, column 9) _catUpdates = {-# LINE 57 "./TypeChecking/CreateTable.ag" #-} leftToEmpty (\as -> [CatCreateTable name_ as defaultSystemColumns]) $ do ats <- _attrs return $ dependsOn (tpeToT _tpe : (map snd ats)) [] ats {-# LINE 10873 "AstInternal.hs" #-} -- "./TypeChecking/CreateTable.ag"(line 63, column 9) _selType = {-# LINE 63 "./TypeChecking/CreateTable.ag" #-} getTypeAnnotation _exprIannotatedTree {-# LINE 10878 "AstInternal.hs" #-} -- "./TypeChecking/CreateTable.ag"(line 65, column 9) _attrs = {-# LINE 65 "./TypeChecking/CreateTable.ag" #-} unwrapSetOfComposite _selType {-# LINE 10883 "AstInternal.hs" #-} -- "./TypeChecking/CreateTable.ag"(line 67, column 9) _backTree = {-# LINE 67 "./TypeChecking/CreateTable.ag" #-} CreateTableAs ann_ name_ _exprIannotatedTree {-# LINE 10888 "AstInternal.hs" #-} -- "./TypeChecking/CreateTable.ag"(line 68, column 9) _statementType = {-# LINE 68 "./TypeChecking/CreateTable.ag" #-} [] {-# LINE 10893 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} CreateTableAs ann_ name_ _exprIannotatedTree {-# LINE 10898 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} CreateTableAs ann_ name_ _exprIoriginalTree {-# LINE 10903 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 10908 "AstInternal.hs" #-} -- copy rule (down) _exprOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 10913 "AstInternal.hs" #-} -- copy rule (down) _exprOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 10918 "AstInternal.hs" #-} ( _exprIannotatedTree,_exprIlibUpdates,_exprIoriginalTree) = (expr_ _exprOcat _exprOlib ) in ( _lhsOannotatedTree,_lhsOcatUpdates,_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_ = (\ _lhsIcat _lhsIinProducedCat _lhsIlib -> (let _lhsOcatUpdates :: ([CatalogUpdate]) _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _lhsOannotatedTree :: Statement _lhsOoriginalTree :: Statement _whOcat :: Catalog _whOlib :: LocalIdentifierBindings _firingOcat :: Catalog _firingOlib :: LocalIdentifierBindings _whIannotatedTree :: TriggerWhen _whIoriginalTree :: TriggerWhen _firingIannotatedTree :: TriggerFire _firingIoriginalTree :: TriggerFire -- "./TypeChecking/Statements.ag"(line 89, column 9) _lhsOcatUpdates = {-# LINE 89 "./TypeChecking/Statements.ag" #-} [] {-# LINE 10951 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 90, column 9) _lhsOlibUpdates = {-# LINE 90 "./TypeChecking/Statements.ag" #-} [] {-# LINE 10956 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} CreateTrigger ann_ name_ _whIannotatedTree events_ tbl_ _firingIannotatedTree fnName_ fnArgs_ {-# LINE 10961 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} CreateTrigger ann_ name_ _whIoriginalTree events_ tbl_ _firingIoriginalTree fnName_ fnArgs_ {-# LINE 10966 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 10971 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 10976 "AstInternal.hs" #-} -- copy rule (down) _whOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 10981 "AstInternal.hs" #-} -- copy rule (down) _whOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 10986 "AstInternal.hs" #-} -- copy rule (down) _firingOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 10991 "AstInternal.hs" #-} -- copy rule (down) _firingOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 10996 "AstInternal.hs" #-} ( _whIannotatedTree,_whIoriginalTree) = (wh_ _whOcat _whOlib ) ( _firingIannotatedTree,_firingIoriginalTree) = (firing_ _firingOcat _firingOlib ) in ( _lhsOannotatedTree,_lhsOcatUpdates,_lhsOlibUpdates,_lhsOoriginalTree))) sem_Statement_CreateType :: Annotation -> String -> T_TypeAttributeDefList -> T_Statement sem_Statement_CreateType ann_ name_ atts_ = (\ _lhsIcat _lhsIinProducedCat _lhsIlib -> (let _lhsOannotatedTree :: Statement _lhsOcatUpdates :: ([CatalogUpdate]) _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _tpe :: (Either [TypeError] Type) _catUpdates :: ([CatalogUpdate]) _lhsOoriginalTree :: Statement _attsOcat :: Catalog _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 ++ [CatUpdates _catUpdates ]) {-# LINE 11029 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 67, column 9) _lhsOcatUpdates = {-# LINE 67 "./TypeChecking/Statements.ag" #-} _catUpdates {-# LINE 11034 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 68, column 9) _lhsOlibUpdates = {-# LINE 68 "./TypeChecking/Statements.ag" #-} _libUpdates {-# LINE 11039 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 73, column 9) _libUpdates = {-# LINE 73 "./TypeChecking/Statements.ag" #-} [] {-# LINE 11044 "AstInternal.hs" #-} -- "./TypeChecking/MiscCreates.ag"(line 51, column 9) _tpe = {-# LINE 51 "./TypeChecking/MiscCreates.ag" #-} Right $ Pseudo Void {-# LINE 11049 "AstInternal.hs" #-} -- "./TypeChecking/MiscCreates.ag"(line 52, column 9) _backTree = {-# LINE 52 "./TypeChecking/MiscCreates.ag" #-} CreateType ann_ name_ _attsIannotatedTree {-# LINE 11054 "AstInternal.hs" #-} -- "./TypeChecking/MiscCreates.ag"(line 53, column 9) _statementType = {-# LINE 53 "./TypeChecking/MiscCreates.ag" #-} [] {-# LINE 11059 "AstInternal.hs" #-} -- "./TypeChecking/MiscCreates.ag"(line 54, column 9) _catUpdates = {-# LINE 54 "./TypeChecking/MiscCreates.ag" #-} [CatCreateComposite name_ _attsIattrs] {-# LINE 11064 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} CreateType ann_ name_ _attsIannotatedTree {-# LINE 11069 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} CreateType ann_ name_ _attsIoriginalTree {-# LINE 11074 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 11079 "AstInternal.hs" #-} -- copy rule (down) _attsOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 11084 "AstInternal.hs" #-} -- copy rule (down) _attsOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 11089 "AstInternal.hs" #-} ( _attsIannotatedTree,_attsIattrs,_attsIoriginalTree) = (atts_ _attsOcat _attsOlib ) in ( _lhsOannotatedTree,_lhsOcatUpdates,_lhsOlibUpdates,_lhsOoriginalTree))) sem_Statement_CreateView :: Annotation -> String -> T_SelectExpression -> T_Statement sem_Statement_CreateView ann_ name_ expr_ = (\ _lhsIcat _lhsIinProducedCat _lhsIlib -> (let _lhsOannotatedTree :: Statement _lhsOcatUpdates :: ([CatalogUpdate]) _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _tpe :: (Either [TypeError] Type) _catUpdates :: ([CatalogUpdate]) _lhsOoriginalTree :: Statement _exprOcat :: Catalog _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 ++ [CatUpdates _catUpdates ]) {-# LINE 11120 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 67, column 9) _lhsOcatUpdates = {-# LINE 67 "./TypeChecking/Statements.ag" #-} _catUpdates {-# LINE 11125 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 68, column 9) _lhsOlibUpdates = {-# LINE 68 "./TypeChecking/Statements.ag" #-} _libUpdates {-# LINE 11130 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 73, column 9) _libUpdates = {-# LINE 73 "./TypeChecking/Statements.ag" #-} [] {-# LINE 11135 "AstInternal.hs" #-} -- "./TypeChecking/MiscCreates.ag"(line 15, column 9) _tpe = {-# LINE 15 "./TypeChecking/MiscCreates.ag" #-} dependsOnRTpe [getTypeAnnotation _exprIannotatedTree] $ Right $ Pseudo Void {-# LINE 11141 "AstInternal.hs" #-} -- "./TypeChecking/MiscCreates.ag"(line 17, column 9) _backTree = {-# LINE 17 "./TypeChecking/MiscCreates.ag" #-} CreateView ann_ name_ _exprIannotatedTree {-# LINE 11146 "AstInternal.hs" #-} -- "./TypeChecking/MiscCreates.ag"(line 18, column 9) _attrs = {-# LINE 18 "./TypeChecking/MiscCreates.ag" #-} case getTypeAnnotation _exprIannotatedTree of SetOfType (CompositeType c) -> c _ -> [] {-# LINE 11153 "AstInternal.hs" #-} -- "./TypeChecking/MiscCreates.ag"(line 21, column 9) _catUpdates = {-# LINE 21 "./TypeChecking/MiscCreates.ag" #-} [CatCreateView name_ _attrs ] {-# LINE 11158 "AstInternal.hs" #-} -- "./TypeChecking/MiscCreates.ag"(line 22, column 9) _statementType = {-# LINE 22 "./TypeChecking/MiscCreates.ag" #-} [] {-# LINE 11163 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} CreateView ann_ name_ _exprIannotatedTree {-# LINE 11168 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} CreateView ann_ name_ _exprIoriginalTree {-# LINE 11173 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 11178 "AstInternal.hs" #-} -- copy rule (down) _exprOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 11183 "AstInternal.hs" #-} -- copy rule (down) _exprOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 11188 "AstInternal.hs" #-} ( _exprIannotatedTree,_exprIlibUpdates,_exprIoriginalTree) = (expr_ _exprOcat _exprOlib ) in ( _lhsOannotatedTree,_lhsOcatUpdates,_lhsOlibUpdates,_lhsOoriginalTree))) sem_Statement_Delete :: Annotation -> String -> T_MaybeBoolExpression -> T_MaybeSelectList -> T_Statement sem_Statement_Delete ann_ table_ whr_ returning_ = (\ _lhsIcat _lhsIinProducedCat _lhsIlib -> (let _lhsOannotatedTree :: Statement _lhsOcatUpdates :: ([CatalogUpdate]) _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _tpe :: (Either [TypeError] Type) _catUpdates :: ([CatalogUpdate]) _whrOlib :: LocalIdentifierBindings _returningOlib :: LocalIdentifierBindings _lhsOoriginalTree :: Statement _whrOcat :: Catalog _returningOcat :: Catalog _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 ++ [CatUpdates _catUpdates ]) {-# LINE 11224 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 67, column 9) _lhsOcatUpdates = {-# LINE 67 "./TypeChecking/Statements.ag" #-} _catUpdates {-# LINE 11229 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 68, column 9) _lhsOlibUpdates = {-# LINE 68 "./TypeChecking/Statements.ag" #-} _libUpdates {-# LINE 11234 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 73, column 9) _libUpdates = {-# LINE 73 "./TypeChecking/Statements.ag" #-} [] {-# LINE 11239 "AstInternal.hs" #-} -- "./TypeChecking/Dml.ag"(line 180, column 9) _tpe = {-# LINE 180 "./TypeChecking/Dml.ag" #-} checkRelationExists _lhsIcat table_ >> Right (Pseudo Void) {-# LINE 11245 "AstInternal.hs" #-} -- "./TypeChecking/Dml.ag"(line 183, column 9) _statementType = {-# LINE 183 "./TypeChecking/Dml.ag" #-} [StatementType (getPlaceholderTypes _whrIannotatedTree) (fromMaybe [] _returningIlistType)] {-# LINE 11251 "AstInternal.hs" #-} -- "./TypeChecking/Dml.ag"(line 186, column 9) _backTree = {-# LINE 186 "./TypeChecking/Dml.ag" #-} Delete ann_ table_ _whrIannotatedTree _returningIannotatedTree {-# LINE 11256 "AstInternal.hs" #-} -- "./TypeChecking/Dml.ag"(line 187, column 9) _catUpdates = {-# LINE 187 "./TypeChecking/Dml.ag" #-} [] {-# LINE 11261 "AstInternal.hs" #-} -- "./TypeChecking/Dml.ag"(line 192, column 9) _lib = {-# LINE 192 "./TypeChecking/Dml.ag" #-} fromRight _lhsIlib $ do columnTypes <- catCompositeAttrs _lhsIcat relationComposites table_ updateBindings _lhsIlib _lhsIcat [LibStackIDs [("", columnTypes)]] {-# LINE 11268 "AstInternal.hs" #-} -- "./TypeChecking/Dml.ag"(line 196, column 9) _whrOlib = {-# LINE 196 "./TypeChecking/Dml.ag" #-} _lib {-# LINE 11273 "AstInternal.hs" #-} -- "./TypeChecking/Dml.ag"(line 197, column 9) _returningOlib = {-# LINE 197 "./TypeChecking/Dml.ag" #-} _lib {-# LINE 11278 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Delete ann_ table_ _whrIannotatedTree _returningIannotatedTree {-# LINE 11283 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Delete ann_ table_ _whrIoriginalTree _returningIoriginalTree {-# LINE 11288 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 11293 "AstInternal.hs" #-} -- copy rule (down) _whrOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 11298 "AstInternal.hs" #-} -- copy rule (down) _returningOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 11303 "AstInternal.hs" #-} ( _whrIannotatedTree,_whrIoriginalTree) = (whr_ _whrOcat _whrOlib ) ( _returningIannotatedTree,_returningIlistType,_returningIoriginalTree) = (returning_ _returningOcat _returningOlib ) in ( _lhsOannotatedTree,_lhsOcatUpdates,_lhsOlibUpdates,_lhsOoriginalTree))) sem_Statement_DropFunction :: Annotation -> T_IfExists -> T_StringTypeNameListPairList -> T_Cascade -> T_Statement sem_Statement_DropFunction ann_ ifE_ sigs_ cascade_ = (\ _lhsIcat _lhsIinProducedCat _lhsIlib -> (let _lhsOannotatedTree :: Statement _lhsOcatUpdates :: ([CatalogUpdate]) _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _tpe :: (Either [TypeError] Type) _catUpdates :: ([CatalogUpdate]) _lhsOoriginalTree :: Statement _ifEOcat :: Catalog _ifEOlib :: LocalIdentifierBindings _sigsOcat :: Catalog _sigsOlib :: LocalIdentifierBindings _cascadeOcat :: Catalog _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 ++ [CatUpdates _catUpdates ]) {-# LINE 11345 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 67, column 9) _lhsOcatUpdates = {-# LINE 67 "./TypeChecking/Statements.ag" #-} _catUpdates {-# LINE 11350 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 68, column 9) _lhsOlibUpdates = {-# LINE 68 "./TypeChecking/Statements.ag" #-} _libUpdates {-# LINE 11355 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 73, column 9) _libUpdates = {-# LINE 73 "./TypeChecking/Statements.ag" #-} [] {-# LINE 11360 "AstInternal.hs" #-} -- "./TypeChecking/Drops.ag"(line 10, column 9) _tpe = {-# LINE 10 "./TypeChecking/Drops.ag" #-} Right $ Pseudo Void {-# LINE 11365 "AstInternal.hs" #-} -- "./TypeChecking/Drops.ag"(line 11, column 9) _backTree = {-# LINE 11 "./TypeChecking/Drops.ag" #-} DropFunction ann_ _ifEIannotatedTree _sigsIannotatedTree _cascadeIannotatedTree {-# LINE 11370 "AstInternal.hs" #-} -- "./TypeChecking/Drops.ag"(line 12, column 9) _catUpdates = {-# LINE 12 "./TypeChecking/Drops.ag" #-} flip map _sigsIfnSigs $ \(nm,args) -> CatDropFunction ifE nm args where ifE = _ifEIannotatedTree == IfExists {-# LINE 11378 "AstInternal.hs" #-} -- "./TypeChecking/Drops.ag"(line 16, column 9) _statementType = {-# LINE 16 "./TypeChecking/Drops.ag" #-} [] {-# LINE 11383 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} DropFunction ann_ _ifEIannotatedTree _sigsIannotatedTree _cascadeIannotatedTree {-# LINE 11388 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} DropFunction ann_ _ifEIoriginalTree _sigsIoriginalTree _cascadeIoriginalTree {-# LINE 11393 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 11398 "AstInternal.hs" #-} -- copy rule (down) _ifEOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 11403 "AstInternal.hs" #-} -- copy rule (down) _ifEOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 11408 "AstInternal.hs" #-} -- copy rule (down) _sigsOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 11413 "AstInternal.hs" #-} -- copy rule (down) _sigsOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 11418 "AstInternal.hs" #-} -- copy rule (down) _cascadeOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 11423 "AstInternal.hs" #-} -- copy rule (down) _cascadeOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 11428 "AstInternal.hs" #-} ( _ifEIannotatedTree,_ifEIoriginalTree) = (ifE_ _ifEOcat _ifEOlib ) ( _sigsIannotatedTree,_sigsIfnSigs,_sigsIoriginalTree) = (sigs_ _sigsOcat _sigsOlib ) ( _cascadeIannotatedTree,_cascadeIoriginalTree) = (cascade_ _cascadeOcat _cascadeOlib ) in ( _lhsOannotatedTree,_lhsOcatUpdates,_lhsOlibUpdates,_lhsOoriginalTree))) sem_Statement_DropSomething :: Annotation -> T_DropType -> T_IfExists -> T_StringList -> T_Cascade -> T_Statement sem_Statement_DropSomething ann_ dropType_ ifE_ names_ cascade_ = (\ _lhsIcat _lhsIinProducedCat _lhsIlib -> (let _lhsOcatUpdates :: ([CatalogUpdate]) _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _lhsOannotatedTree :: Statement _lhsOoriginalTree :: Statement _dropTypeOcat :: Catalog _dropTypeOlib :: LocalIdentifierBindings _ifEOcat :: Catalog _ifEOlib :: LocalIdentifierBindings _namesOcat :: Catalog _namesOlib :: LocalIdentifierBindings _cascadeOcat :: Catalog _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) _lhsOcatUpdates = {-# LINE 89 "./TypeChecking/Statements.ag" #-} [] {-# LINE 11471 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 90, column 9) _lhsOlibUpdates = {-# LINE 90 "./TypeChecking/Statements.ag" #-} [] {-# LINE 11476 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} DropSomething ann_ _dropTypeIannotatedTree _ifEIannotatedTree _namesIannotatedTree _cascadeIannotatedTree {-# LINE 11481 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} DropSomething ann_ _dropTypeIoriginalTree _ifEIoriginalTree _namesIoriginalTree _cascadeIoriginalTree {-# LINE 11486 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 11491 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 11496 "AstInternal.hs" #-} -- copy rule (down) _dropTypeOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 11501 "AstInternal.hs" #-} -- copy rule (down) _dropTypeOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 11506 "AstInternal.hs" #-} -- copy rule (down) _ifEOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 11511 "AstInternal.hs" #-} -- copy rule (down) _ifEOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 11516 "AstInternal.hs" #-} -- copy rule (down) _namesOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 11521 "AstInternal.hs" #-} -- copy rule (down) _namesOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 11526 "AstInternal.hs" #-} -- copy rule (down) _cascadeOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 11531 "AstInternal.hs" #-} -- copy rule (down) _cascadeOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 11536 "AstInternal.hs" #-} ( _dropTypeIannotatedTree,_dropTypeIoriginalTree) = (dropType_ _dropTypeOcat _dropTypeOlib ) ( _ifEIannotatedTree,_ifEIoriginalTree) = (ifE_ _ifEOcat _ifEOlib ) ( _namesIannotatedTree,_namesIoriginalTree,_namesIstrings) = (names_ _namesOcat _namesOlib ) ( _cascadeIannotatedTree,_cascadeIoriginalTree) = (cascade_ _cascadeOcat _cascadeOlib ) in ( _lhsOannotatedTree,_lhsOcatUpdates,_lhsOlibUpdates,_lhsOoriginalTree))) sem_Statement_Execute :: Annotation -> T_Expression -> T_Statement sem_Statement_Execute ann_ expr_ = (\ _lhsIcat _lhsIinProducedCat _lhsIlib -> (let _lhsOcatUpdates :: ([CatalogUpdate]) _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _lhsOannotatedTree :: Statement _lhsOoriginalTree :: Statement _exprOcat :: Catalog _exprOlib :: LocalIdentifierBindings _exprIannotatedTree :: Expression _exprIliftedColumnName :: String _exprIoriginalTree :: Expression -- "./TypeChecking/Statements.ag"(line 89, column 9) _lhsOcatUpdates = {-# LINE 89 "./TypeChecking/Statements.ag" #-} [] {-# LINE 11566 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 90, column 9) _lhsOlibUpdates = {-# LINE 90 "./TypeChecking/Statements.ag" #-} [] {-# LINE 11571 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Execute ann_ _exprIannotatedTree {-# LINE 11576 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Execute ann_ _exprIoriginalTree {-# LINE 11581 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 11586 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 11591 "AstInternal.hs" #-} -- copy rule (down) _exprOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 11596 "AstInternal.hs" #-} -- copy rule (down) _exprOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 11601 "AstInternal.hs" #-} ( _exprIannotatedTree,_exprIliftedColumnName,_exprIoriginalTree) = (expr_ _exprOcat _exprOlib ) in ( _lhsOannotatedTree,_lhsOcatUpdates,_lhsOlibUpdates,_lhsOoriginalTree))) sem_Statement_ExecuteInto :: Annotation -> T_Expression -> T_StringList -> T_Statement sem_Statement_ExecuteInto ann_ expr_ targets_ = (\ _lhsIcat _lhsIinProducedCat _lhsIlib -> (let _lhsOcatUpdates :: ([CatalogUpdate]) _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _lhsOannotatedTree :: Statement _lhsOoriginalTree :: Statement _exprOcat :: Catalog _exprOlib :: LocalIdentifierBindings _targetsOcat :: Catalog _targetsOlib :: LocalIdentifierBindings _exprIannotatedTree :: Expression _exprIliftedColumnName :: String _exprIoriginalTree :: Expression _targetsIannotatedTree :: StringList _targetsIoriginalTree :: StringList _targetsIstrings :: ([String]) -- "./TypeChecking/Statements.ag"(line 89, column 9) _lhsOcatUpdates = {-# LINE 89 "./TypeChecking/Statements.ag" #-} [] {-# LINE 11631 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 90, column 9) _lhsOlibUpdates = {-# LINE 90 "./TypeChecking/Statements.ag" #-} [] {-# LINE 11636 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} ExecuteInto ann_ _exprIannotatedTree _targetsIannotatedTree {-# LINE 11641 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} ExecuteInto ann_ _exprIoriginalTree _targetsIoriginalTree {-# LINE 11646 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 11651 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 11656 "AstInternal.hs" #-} -- copy rule (down) _exprOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 11661 "AstInternal.hs" #-} -- copy rule (down) _exprOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 11666 "AstInternal.hs" #-} -- copy rule (down) _targetsOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 11671 "AstInternal.hs" #-} -- copy rule (down) _targetsOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 11676 "AstInternal.hs" #-} ( _exprIannotatedTree,_exprIliftedColumnName,_exprIoriginalTree) = (expr_ _exprOcat _exprOlib ) ( _targetsIannotatedTree,_targetsIoriginalTree,_targetsIstrings) = (targets_ _targetsOcat _targetsOlib ) in ( _lhsOannotatedTree,_lhsOcatUpdates,_lhsOlibUpdates,_lhsOoriginalTree))) sem_Statement_ForIntegerStatement :: Annotation -> String -> T_Expression -> T_Expression -> T_StatementList -> T_Statement sem_Statement_ForIntegerStatement ann_ var_ from_ to_ sts_ = (\ _lhsIcat _lhsIinProducedCat _lhsIlib -> (let _lhsOannotatedTree :: Statement _lhsOcatUpdates :: ([CatalogUpdate]) _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _stsOcatUpdates :: ([CatalogUpdate]) _stsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _tpe :: (Either [TypeError] Type) _stsOlib :: LocalIdentifierBindings _catUpdates :: ([CatalogUpdate]) _lhsOoriginalTree :: Statement _fromOcat :: Catalog _fromOlib :: LocalIdentifierBindings _toOcat :: Catalog _toOlib :: LocalIdentifierBindings _stsOcat :: Catalog _fromIannotatedTree :: Expression _fromIliftedColumnName :: String _fromIoriginalTree :: Expression _toIannotatedTree :: Expression _toIliftedColumnName :: String _toIoriginalTree :: Expression _stsIannotatedTree :: StatementList _stsIoriginalTree :: StatementList _stsIproducedCat :: Catalog _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 ++ [CatUpdates _catUpdates ]) {-# LINE 11724 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 67, column 9) _lhsOcatUpdates = {-# LINE 67 "./TypeChecking/Statements.ag" #-} _catUpdates {-# LINE 11729 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 68, column 9) _lhsOlibUpdates = {-# LINE 68 "./TypeChecking/Statements.ag" #-} _libUpdates {-# LINE 11734 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 73, column 9) _libUpdates = {-# LINE 73 "./TypeChecking/Statements.ag" #-} [] {-# LINE 11739 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 110, column 9) _stsOcatUpdates = {-# LINE 110 "./TypeChecking/Statements.ag" #-} [] {-# LINE 11744 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 111, column 9) _stsOlibUpdates = {-# LINE 111 "./TypeChecking/Statements.ag" #-} [] {-# LINE 11749 "AstInternal.hs" #-} -- "./TypeChecking/Plpgsql.ag"(line 36, column 9) _varTypeE = {-# LINE 36 "./TypeChecking/Plpgsql.ag" #-} libLookupID _lhsIlib var_ {-# LINE 11754 "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 _lhsIcat fromType t Left _ -> return () return $ Pseudo Void {-# LINE 11767 "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 _lhsIcat [LibStackIDs [("", [(var_,getTypeAnnotation _fromIannotatedTree)])]] _ -> _lhsIlib {-# LINE 11777 "AstInternal.hs" #-} -- "./TypeChecking/Plpgsql.ag"(line 56, column 9) _backTree = {-# LINE 56 "./TypeChecking/Plpgsql.ag" #-} ForIntegerStatement ann_ var_ _fromIannotatedTree _toIannotatedTree _stsIannotatedTree {-# LINE 11782 "AstInternal.hs" #-} -- "./TypeChecking/Plpgsql.ag"(line 57, column 9) _catUpdates = {-# LINE 57 "./TypeChecking/Plpgsql.ag" #-} [] {-# LINE 11787 "AstInternal.hs" #-} -- "./TypeChecking/Plpgsql.ag"(line 58, column 9) _statementType = {-# LINE 58 "./TypeChecking/Plpgsql.ag" #-} [] {-# LINE 11792 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} ForIntegerStatement ann_ var_ _fromIannotatedTree _toIannotatedTree _stsIannotatedTree {-# LINE 11797 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} ForIntegerStatement ann_ var_ _fromIoriginalTree _toIoriginalTree _stsIoriginalTree {-# LINE 11802 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 11807 "AstInternal.hs" #-} -- copy rule (down) _fromOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 11812 "AstInternal.hs" #-} -- copy rule (down) _fromOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 11817 "AstInternal.hs" #-} -- copy rule (down) _toOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 11822 "AstInternal.hs" #-} -- copy rule (down) _toOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 11827 "AstInternal.hs" #-} -- copy rule (down) _stsOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 11832 "AstInternal.hs" #-} ( _fromIannotatedTree,_fromIliftedColumnName,_fromIoriginalTree) = (from_ _fromOcat _fromOlib ) ( _toIannotatedTree,_toIliftedColumnName,_toIoriginalTree) = (to_ _toOcat _toOlib ) ( _stsIannotatedTree,_stsIoriginalTree,_stsIproducedCat,_stsIproducedLib) = (sts_ _stsOcat _stsOcatUpdates _stsOlib _stsOlibUpdates ) in ( _lhsOannotatedTree,_lhsOcatUpdates,_lhsOlibUpdates,_lhsOoriginalTree))) sem_Statement_ForSelectStatement :: Annotation -> String -> T_SelectExpression -> T_StatementList -> T_Statement sem_Statement_ForSelectStatement ann_ var_ sel_ sts_ = (\ _lhsIcat _lhsIinProducedCat _lhsIlib -> (let _lhsOannotatedTree :: Statement _lhsOcatUpdates :: ([CatalogUpdate]) _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _stsOcatUpdates :: ([CatalogUpdate]) _stsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _tpe :: (Either [TypeError] Type) _stsOlib :: LocalIdentifierBindings _catUpdates :: ([CatalogUpdate]) _lhsOoriginalTree :: Statement _selOcat :: Catalog _selOlib :: LocalIdentifierBindings _stsOcat :: Catalog _selIannotatedTree :: SelectExpression _selIlibUpdates :: ([LocalIdentifierBindingsUpdate]) _selIoriginalTree :: SelectExpression _stsIannotatedTree :: StatementList _stsIoriginalTree :: StatementList _stsIproducedCat :: Catalog _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 ++ [CatUpdates _catUpdates ]) {-# LINE 11876 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 67, column 9) _lhsOcatUpdates = {-# LINE 67 "./TypeChecking/Statements.ag" #-} _catUpdates {-# LINE 11881 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 68, column 9) _lhsOlibUpdates = {-# LINE 68 "./TypeChecking/Statements.ag" #-} _libUpdates {-# LINE 11886 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 73, column 9) _libUpdates = {-# LINE 73 "./TypeChecking/Statements.ag" #-} [] {-# LINE 11891 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 110, column 9) _stsOcatUpdates = {-# LINE 110 "./TypeChecking/Statements.ag" #-} [] {-# LINE 11896 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 111, column 9) _stsOlibUpdates = {-# LINE 111 "./TypeChecking/Statements.ag" #-} [] {-# LINE 11901 "AstInternal.hs" #-} -- "./TypeChecking/Plpgsql.ag"(line 63, column 9) _selType = {-# LINE 63 "./TypeChecking/Plpgsql.ag" #-} getTypeAnnotation _selIannotatedTree {-# LINE 11906 "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 _lhsIcat _selType toType return $ Pseudo Void {-# LINE 11916 "AstInternal.hs" #-} -- "./TypeChecking/Plpgsql.ag"(line 75, column 9) _stsOlib = {-# LINE 75 "./TypeChecking/Plpgsql.ag" #-} if okToUpdate then fromRight _lhsIlib $ updateBindings _lhsIlib _lhsIcat [LibStackIDs [("", [(var_,_selType )])]] else _lhsIlib where okToUpdate = isRight _tpe && _selType /= TypeCheckFailed {-# LINE 11926 "AstInternal.hs" #-} -- "./TypeChecking/Plpgsql.ag"(line 84, column 9) _backTree = {-# LINE 84 "./TypeChecking/Plpgsql.ag" #-} ForSelectStatement ann_ var_ _selIannotatedTree _stsIannotatedTree {-# LINE 11931 "AstInternal.hs" #-} -- "./TypeChecking/Plpgsql.ag"(line 85, column 9) _catUpdates = {-# LINE 85 "./TypeChecking/Plpgsql.ag" #-} [] {-# LINE 11936 "AstInternal.hs" #-} -- "./TypeChecking/Plpgsql.ag"(line 86, column 9) _statementType = {-# LINE 86 "./TypeChecking/Plpgsql.ag" #-} [] {-# LINE 11941 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} ForSelectStatement ann_ var_ _selIannotatedTree _stsIannotatedTree {-# LINE 11946 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} ForSelectStatement ann_ var_ _selIoriginalTree _stsIoriginalTree {-# LINE 11951 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 11956 "AstInternal.hs" #-} -- copy rule (down) _selOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 11961 "AstInternal.hs" #-} -- copy rule (down) _selOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 11966 "AstInternal.hs" #-} -- copy rule (down) _stsOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 11971 "AstInternal.hs" #-} ( _selIannotatedTree,_selIlibUpdates,_selIoriginalTree) = (sel_ _selOcat _selOlib ) ( _stsIannotatedTree,_stsIoriginalTree,_stsIproducedCat,_stsIproducedLib) = (sts_ _stsOcat _stsOcatUpdates _stsOlib _stsOlibUpdates ) in ( _lhsOannotatedTree,_lhsOcatUpdates,_lhsOlibUpdates,_lhsOoriginalTree))) sem_Statement_If :: Annotation -> T_ExpressionStatementListPairList -> T_StatementList -> T_Statement sem_Statement_If ann_ cases_ els_ = (\ _lhsIcat _lhsIinProducedCat _lhsIlib -> (let _lhsOcatUpdates :: ([CatalogUpdate]) _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _elsOcatUpdates :: ([CatalogUpdate]) _elsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _lhsOannotatedTree :: Statement _lhsOoriginalTree :: Statement _casesOcat :: Catalog _casesOlib :: LocalIdentifierBindings _elsOcat :: Catalog _elsOlib :: LocalIdentifierBindings _casesIannotatedTree :: ExpressionStatementListPairList _casesIoriginalTree :: ExpressionStatementListPairList _elsIannotatedTree :: StatementList _elsIoriginalTree :: StatementList _elsIproducedCat :: Catalog _elsIproducedLib :: LocalIdentifierBindings -- "./TypeChecking/Statements.ag"(line 89, column 9) _lhsOcatUpdates = {-# LINE 89 "./TypeChecking/Statements.ag" #-} [] {-# LINE 12005 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 90, column 9) _lhsOlibUpdates = {-# LINE 90 "./TypeChecking/Statements.ag" #-} [] {-# LINE 12010 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 106, column 9) _elsOcatUpdates = {-# LINE 106 "./TypeChecking/Statements.ag" #-} [] {-# LINE 12015 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 107, column 9) _elsOlibUpdates = {-# LINE 107 "./TypeChecking/Statements.ag" #-} [] {-# LINE 12020 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} If ann_ _casesIannotatedTree _elsIannotatedTree {-# LINE 12025 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} If ann_ _casesIoriginalTree _elsIoriginalTree {-# LINE 12030 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 12035 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 12040 "AstInternal.hs" #-} -- copy rule (down) _casesOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 12045 "AstInternal.hs" #-} -- copy rule (down) _casesOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 12050 "AstInternal.hs" #-} -- copy rule (down) _elsOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 12055 "AstInternal.hs" #-} -- copy rule (down) _elsOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 12060 "AstInternal.hs" #-} ( _casesIannotatedTree,_casesIoriginalTree) = (cases_ _casesOcat _casesOlib ) ( _elsIannotatedTree,_elsIoriginalTree,_elsIproducedCat,_elsIproducedLib) = (els_ _elsOcat _elsOcatUpdates _elsOlib _elsOlibUpdates ) in ( _lhsOannotatedTree,_lhsOcatUpdates,_lhsOlibUpdates,_lhsOoriginalTree))) sem_Statement_Insert :: Annotation -> String -> T_StringList -> T_SelectExpression -> T_MaybeSelectList -> T_Statement sem_Statement_Insert ann_ table_ targetCols_ insData_ returning_ = (\ _lhsIcat _lhsIinProducedCat _lhsIlib -> (let _lhsOannotatedTree :: Statement _lhsOcatUpdates :: ([CatalogUpdate]) _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _tpe :: (Either [TypeError] Type) _catUpdates :: ([CatalogUpdate]) _returningOlib :: LocalIdentifierBindings _lhsOoriginalTree :: Statement _targetColsOcat :: Catalog _targetColsOlib :: LocalIdentifierBindings _insDataOcat :: Catalog _insDataOlib :: LocalIdentifierBindings _returningOcat :: Catalog _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 ++ [CatUpdates _catUpdates ]) {-# LINE 12105 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 67, column 9) _lhsOcatUpdates = {-# LINE 67 "./TypeChecking/Statements.ag" #-} _catUpdates {-# LINE 12110 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 68, column 9) _lhsOlibUpdates = {-# LINE 68 "./TypeChecking/Statements.ag" #-} _libUpdates {-# LINE 12115 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 73, column 9) _libUpdates = {-# LINE 73 "./TypeChecking/Statements.ag" #-} [] {-# LINE 12120 "AstInternal.hs" #-} -- "./TypeChecking/Dml.ag"(line 18, column 9) _tpe = {-# LINE 18 "./TypeChecking/Dml.ag" #-} dependsOnRTpe [getTypeAnnotation _insDataIannotatedTree] $ do _columnTypes Right $ Pseudo Void {-# LINE 12127 "AstInternal.hs" #-} -- "./TypeChecking/Dml.ag"(line 22, column 9) _statementType = {-# LINE 22 "./TypeChecking/Dml.ag" #-} leftToEmpty (\ct -> [StatementType (getPlaceholderTypes _insDataAddedInferredTypes ) (fromMaybe [] _returningIlistType)]) _columnTypes {-# LINE 12132 "AstInternal.hs" #-} -- "./TypeChecking/Dml.ag"(line 25, column 9) _columnTypes = {-# LINE 25 "./TypeChecking/Dml.ag" #-} do tys <- unwrapSetOfComposite $ getTypeAnnotation _insDataIannotatedTree checkColumnConsistency _lhsIcat table_ _targetColsIstrings tys {-# LINE 12143 "AstInternal.hs" #-} -- "./TypeChecking/Dml.ag"(line 33, column 9) _insDataAddedInferredTypes = {-# LINE 33 "./TypeChecking/Dml.ag" #-} case _insDataIannotatedTree of Values ann [exl] -> let fargs = map snd (fromRight [] _columnTypes ) ++ repeat TypeCheckFailed newExl = map (\(ex,ty) -> updateAnnotation (++ [InferredType ty]) ex) $ zip exl fargs in Values ann [newExl] x -> x {-# LINE 12153 "AstInternal.hs" #-} -- "./TypeChecking/Dml.ag"(line 41, column 9) _backTree = {-# LINE 41 "./TypeChecking/Dml.ag" #-} Insert ann_ table_ _targetColsIannotatedTree _insDataAddedInferredTypes _returningIannotatedTree {-# LINE 12159 "AstInternal.hs" #-} -- "./TypeChecking/Dml.ag"(line 43, column 9) _catUpdates = {-# LINE 43 "./TypeChecking/Dml.ag" #-} [] {-# LINE 12164 "AstInternal.hs" #-} -- "./TypeChecking/Dml.ag"(line 49, column 9) _returningOlib = {-# LINE 49 "./TypeChecking/Dml.ag" #-} fromRight _lhsIlib $ do atts <- catCompositeAttrs _lhsIcat relationComposites table_ updateBindings _lhsIlib _lhsIcat [LibStackIDs [("", atts)]] {-# LINE 12171 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Insert ann_ table_ _targetColsIannotatedTree _insDataIannotatedTree _returningIannotatedTree {-# LINE 12176 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Insert ann_ table_ _targetColsIoriginalTree _insDataIoriginalTree _returningIoriginalTree {-# LINE 12181 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 12186 "AstInternal.hs" #-} -- copy rule (down) _targetColsOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 12191 "AstInternal.hs" #-} -- copy rule (down) _targetColsOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 12196 "AstInternal.hs" #-} -- copy rule (down) _insDataOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 12201 "AstInternal.hs" #-} -- copy rule (down) _insDataOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 12206 "AstInternal.hs" #-} -- copy rule (down) _returningOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 12211 "AstInternal.hs" #-} ( _targetColsIannotatedTree,_targetColsIoriginalTree,_targetColsIstrings) = (targetCols_ _targetColsOcat _targetColsOlib ) ( _insDataIannotatedTree,_insDataIlibUpdates,_insDataIoriginalTree) = (insData_ _insDataOcat _insDataOlib ) ( _returningIannotatedTree,_returningIlistType,_returningIoriginalTree) = (returning_ _returningOcat _returningOlib ) in ( _lhsOannotatedTree,_lhsOcatUpdates,_lhsOlibUpdates,_lhsOoriginalTree))) sem_Statement_Notify :: Annotation -> String -> T_Statement sem_Statement_Notify ann_ name_ = (\ _lhsIcat _lhsIinProducedCat _lhsIlib -> (let _lhsOcatUpdates :: ([CatalogUpdate]) _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _lhsOannotatedTree :: Statement _lhsOoriginalTree :: Statement -- "./TypeChecking/Statements.ag"(line 73, column 9) _libUpdates = {-# LINE 73 "./TypeChecking/Statements.ag" #-} [] {-# LINE 12234 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 89, column 9) _lhsOcatUpdates = {-# LINE 89 "./TypeChecking/Statements.ag" #-} [] {-# LINE 12239 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 90, column 9) _lhsOlibUpdates = {-# LINE 90 "./TypeChecking/Statements.ag" #-} [] {-# LINE 12244 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Notify ann_ name_ {-# LINE 12249 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Notify ann_ name_ {-# LINE 12254 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 12259 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 12264 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOcatUpdates,_lhsOlibUpdates,_lhsOoriginalTree))) sem_Statement_NullStatement :: Annotation -> T_Statement sem_Statement_NullStatement ann_ = (\ _lhsIcat _lhsIinProducedCat _lhsIlib -> (let _lhsOcatUpdates :: ([CatalogUpdate]) _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _lhsOannotatedTree :: Statement _lhsOoriginalTree :: Statement -- "./TypeChecking/Statements.ag"(line 89, column 9) _lhsOcatUpdates = {-# LINE 89 "./TypeChecking/Statements.ag" #-} [] {-# LINE 12280 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 90, column 9) _lhsOlibUpdates = {-# LINE 90 "./TypeChecking/Statements.ag" #-} [] {-# LINE 12285 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} NullStatement ann_ {-# LINE 12290 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} NullStatement ann_ {-# LINE 12295 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 12300 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 12305 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOcatUpdates,_lhsOlibUpdates,_lhsOoriginalTree))) sem_Statement_Perform :: Annotation -> T_Expression -> T_Statement sem_Statement_Perform ann_ expr_ = (\ _lhsIcat _lhsIinProducedCat _lhsIlib -> (let _lhsOcatUpdates :: ([CatalogUpdate]) _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _lhsOannotatedTree :: Statement _lhsOoriginalTree :: Statement _exprOcat :: Catalog _exprOlib :: LocalIdentifierBindings _exprIannotatedTree :: Expression _exprIliftedColumnName :: String _exprIoriginalTree :: Expression -- "./TypeChecking/Statements.ag"(line 89, column 9) _lhsOcatUpdates = {-# LINE 89 "./TypeChecking/Statements.ag" #-} [] {-# LINE 12327 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 90, column 9) _lhsOlibUpdates = {-# LINE 90 "./TypeChecking/Statements.ag" #-} [] {-# LINE 12332 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Perform ann_ _exprIannotatedTree {-# LINE 12337 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Perform ann_ _exprIoriginalTree {-# LINE 12342 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 12347 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 12352 "AstInternal.hs" #-} -- copy rule (down) _exprOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 12357 "AstInternal.hs" #-} -- copy rule (down) _exprOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 12362 "AstInternal.hs" #-} ( _exprIannotatedTree,_exprIliftedColumnName,_exprIoriginalTree) = (expr_ _exprOcat _exprOlib ) in ( _lhsOannotatedTree,_lhsOcatUpdates,_lhsOlibUpdates,_lhsOoriginalTree))) sem_Statement_Raise :: Annotation -> T_RaiseType -> String -> T_ExpressionList -> T_Statement sem_Statement_Raise ann_ level_ message_ args_ = (\ _lhsIcat _lhsIinProducedCat _lhsIlib -> (let _lhsOcatUpdates :: ([CatalogUpdate]) _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _lhsOannotatedTree :: Statement _lhsOoriginalTree :: Statement _levelOcat :: Catalog _levelOlib :: LocalIdentifierBindings _argsOcat :: Catalog _argsOlib :: LocalIdentifierBindings _levelIannotatedTree :: RaiseType _levelIoriginalTree :: RaiseType _argsIannotatedTree :: ExpressionList _argsIoriginalTree :: ExpressionList _argsItypeList :: ([Type]) -- "./TypeChecking/Statements.ag"(line 89, column 9) _lhsOcatUpdates = {-# LINE 89 "./TypeChecking/Statements.ag" #-} [] {-# LINE 12392 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 90, column 9) _lhsOlibUpdates = {-# LINE 90 "./TypeChecking/Statements.ag" #-} [] {-# LINE 12397 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Raise ann_ _levelIannotatedTree message_ _argsIannotatedTree {-# LINE 12402 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Raise ann_ _levelIoriginalTree message_ _argsIoriginalTree {-# LINE 12407 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 12412 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 12417 "AstInternal.hs" #-} -- copy rule (down) _levelOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 12422 "AstInternal.hs" #-} -- copy rule (down) _levelOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 12427 "AstInternal.hs" #-} -- copy rule (down) _argsOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 12432 "AstInternal.hs" #-} -- copy rule (down) _argsOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 12437 "AstInternal.hs" #-} ( _levelIannotatedTree,_levelIoriginalTree) = (level_ _levelOcat _levelOlib ) ( _argsIannotatedTree,_argsIoriginalTree,_argsItypeList) = (args_ _argsOcat _argsOlib ) in ( _lhsOannotatedTree,_lhsOcatUpdates,_lhsOlibUpdates,_lhsOoriginalTree))) sem_Statement_Return :: Annotation -> T_MaybeExpression -> T_Statement sem_Statement_Return ann_ value_ = (\ _lhsIcat _lhsIinProducedCat _lhsIlib -> (let _lhsOannotatedTree :: Statement _lhsOcatUpdates :: ([CatalogUpdate]) _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _tpe :: (Either [TypeError] Type) _catUpdates :: ([CatalogUpdate]) _lhsOoriginalTree :: Statement _valueOcat :: Catalog _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 ++ [CatUpdates _catUpdates ]) {-# LINE 12468 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 67, column 9) _lhsOcatUpdates = {-# LINE 67 "./TypeChecking/Statements.ag" #-} _catUpdates {-# LINE 12473 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 68, column 9) _lhsOlibUpdates = {-# LINE 68 "./TypeChecking/Statements.ag" #-} _libUpdates {-# LINE 12478 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 73, column 9) _libUpdates = {-# LINE 73 "./TypeChecking/Statements.ag" #-} [] {-# LINE 12483 "AstInternal.hs" #-} -- "./TypeChecking/Plpgsql.ag"(line 12, column 9) _tpe = {-# LINE 12 "./TypeChecking/Plpgsql.ag" #-} dependsOnRTpe [maybe typeBool getTypeAnnotation _valueIannotatedTree] $ Right $ Pseudo Void {-# LINE 12490 "AstInternal.hs" #-} -- "./TypeChecking/Plpgsql.ag"(line 16, column 9) _backTree = {-# LINE 16 "./TypeChecking/Plpgsql.ag" #-} Return ann_ _valueIannotatedTree {-# LINE 12495 "AstInternal.hs" #-} -- "./TypeChecking/Plpgsql.ag"(line 17, column 9) _catUpdates = {-# LINE 17 "./TypeChecking/Plpgsql.ag" #-} [] {-# LINE 12500 "AstInternal.hs" #-} -- "./TypeChecking/Plpgsql.ag"(line 18, column 9) _statementType = {-# LINE 18 "./TypeChecking/Plpgsql.ag" #-} [] {-# LINE 12505 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Return ann_ _valueIannotatedTree {-# LINE 12510 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Return ann_ _valueIoriginalTree {-# LINE 12515 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 12520 "AstInternal.hs" #-} -- copy rule (down) _valueOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 12525 "AstInternal.hs" #-} -- copy rule (down) _valueOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 12530 "AstInternal.hs" #-} ( _valueIannotatedTree,_valueIoriginalTree) = (value_ _valueOcat _valueOlib ) in ( _lhsOannotatedTree,_lhsOcatUpdates,_lhsOlibUpdates,_lhsOoriginalTree))) sem_Statement_ReturnNext :: Annotation -> T_Expression -> T_Statement sem_Statement_ReturnNext ann_ expr_ = (\ _lhsIcat _lhsIinProducedCat _lhsIlib -> (let _lhsOcatUpdates :: ([CatalogUpdate]) _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _lhsOannotatedTree :: Statement _lhsOoriginalTree :: Statement _exprOcat :: Catalog _exprOlib :: LocalIdentifierBindings _exprIannotatedTree :: Expression _exprIliftedColumnName :: String _exprIoriginalTree :: Expression -- "./TypeChecking/Statements.ag"(line 89, column 9) _lhsOcatUpdates = {-# LINE 89 "./TypeChecking/Statements.ag" #-} [] {-# LINE 12554 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 90, column 9) _lhsOlibUpdates = {-# LINE 90 "./TypeChecking/Statements.ag" #-} [] {-# LINE 12559 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} ReturnNext ann_ _exprIannotatedTree {-# LINE 12564 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} ReturnNext ann_ _exprIoriginalTree {-# LINE 12569 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 12574 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 12579 "AstInternal.hs" #-} -- copy rule (down) _exprOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 12584 "AstInternal.hs" #-} -- copy rule (down) _exprOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 12589 "AstInternal.hs" #-} ( _exprIannotatedTree,_exprIliftedColumnName,_exprIoriginalTree) = (expr_ _exprOcat _exprOlib ) in ( _lhsOannotatedTree,_lhsOcatUpdates,_lhsOlibUpdates,_lhsOoriginalTree))) sem_Statement_ReturnQuery :: Annotation -> T_SelectExpression -> T_Statement sem_Statement_ReturnQuery ann_ sel_ = (\ _lhsIcat _lhsIinProducedCat _lhsIlib -> (let _lhsOcatUpdates :: ([CatalogUpdate]) _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _lhsOannotatedTree :: Statement _lhsOoriginalTree :: Statement _selOcat :: Catalog _selOlib :: LocalIdentifierBindings _selIannotatedTree :: SelectExpression _selIlibUpdates :: ([LocalIdentifierBindingsUpdate]) _selIoriginalTree :: SelectExpression -- "./TypeChecking/Statements.ag"(line 89, column 9) _lhsOcatUpdates = {-# LINE 89 "./TypeChecking/Statements.ag" #-} [] {-# LINE 12613 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 90, column 9) _lhsOlibUpdates = {-# LINE 90 "./TypeChecking/Statements.ag" #-} [] {-# LINE 12618 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} ReturnQuery ann_ _selIannotatedTree {-# LINE 12623 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} ReturnQuery ann_ _selIoriginalTree {-# LINE 12628 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 12633 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 12638 "AstInternal.hs" #-} -- copy rule (down) _selOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 12643 "AstInternal.hs" #-} -- copy rule (down) _selOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 12648 "AstInternal.hs" #-} ( _selIannotatedTree,_selIlibUpdates,_selIoriginalTree) = (sel_ _selOcat _selOlib ) in ( _lhsOannotatedTree,_lhsOcatUpdates,_lhsOlibUpdates,_lhsOoriginalTree))) sem_Statement_SelectStatement :: Annotation -> T_SelectExpression -> T_Statement sem_Statement_SelectStatement ann_ ex_ = (\ _lhsIcat _lhsIinProducedCat _lhsIlib -> (let _lhsOannotatedTree :: Statement _lhsOcatUpdates :: ([CatalogUpdate]) _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _tpe :: (Either [TypeError] Type) _catUpdates :: ([CatalogUpdate]) _lhsOoriginalTree :: Statement _exOcat :: Catalog _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 ++ [CatUpdates _catUpdates ]) {-# LINE 12678 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 67, column 9) _lhsOcatUpdates = {-# LINE 67 "./TypeChecking/Statements.ag" #-} _catUpdates {-# LINE 12683 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 68, column 9) _lhsOlibUpdates = {-# LINE 68 "./TypeChecking/Statements.ag" #-} _libUpdates {-# LINE 12688 "AstInternal.hs" #-} -- "./TypeChecking/SelectStatement.ag"(line 14, column 9) _tpe = {-# LINE 14 "./TypeChecking/SelectStatement.ag" #-} dependsOnRTpe [getTypeAnnotation _exIannotatedTree] $ Right $ Pseudo Void {-# LINE 12693 "AstInternal.hs" #-} -- "./TypeChecking/SelectStatement.ag"(line 15, column 9) _statementType = {-# LINE 15 "./TypeChecking/SelectStatement.ag" #-} [StatementType (getPlaceholderTypes _exIannotatedTree) $ leftToEmpty id $ unwrapSetOfComposite $ getTypeAnnotation _exIannotatedTree] {-# LINE 12700 "AstInternal.hs" #-} -- "./TypeChecking/SelectStatement.ag"(line 18, column 9) _backTree = {-# LINE 18 "./TypeChecking/SelectStatement.ag" #-} SelectStatement ann_ _exIannotatedTree {-# LINE 12705 "AstInternal.hs" #-} -- "./TypeChecking/SelectStatement.ag"(line 19, column 9) _catUpdates = {-# LINE 19 "./TypeChecking/SelectStatement.ag" #-} [] {-# LINE 12710 "AstInternal.hs" #-} -- "./TypeChecking/SelectLists.ag"(line 79, column 9) _libUpdates = {-# LINE 79 "./TypeChecking/SelectLists.ag" #-} _exIlibUpdates {-# LINE 12715 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} SelectStatement ann_ _exIannotatedTree {-# LINE 12720 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} SelectStatement ann_ _exIoriginalTree {-# LINE 12725 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 12730 "AstInternal.hs" #-} -- copy rule (down) _exOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 12735 "AstInternal.hs" #-} -- copy rule (down) _exOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 12740 "AstInternal.hs" #-} ( _exIannotatedTree,_exIlibUpdates,_exIoriginalTree) = (ex_ _exOcat _exOlib ) in ( _lhsOannotatedTree,_lhsOcatUpdates,_lhsOlibUpdates,_lhsOoriginalTree))) sem_Statement_Set :: Annotation -> String -> ([SetValue]) -> T_Statement sem_Statement_Set ann_ name_ values_ = (\ _lhsIcat _lhsIinProducedCat _lhsIlib -> (let _lhsOcatUpdates :: ([CatalogUpdate]) _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _lhsOannotatedTree :: Statement _lhsOoriginalTree :: Statement -- "./TypeChecking/Statements.ag"(line 73, column 9) _libUpdates = {-# LINE 73 "./TypeChecking/Statements.ag" #-} [] {-# LINE 12760 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 89, column 9) _lhsOcatUpdates = {-# LINE 89 "./TypeChecking/Statements.ag" #-} [] {-# LINE 12765 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 90, column 9) _lhsOlibUpdates = {-# LINE 90 "./TypeChecking/Statements.ag" #-} [] {-# LINE 12770 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Set ann_ name_ values_ {-# LINE 12775 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Set ann_ name_ values_ {-# LINE 12780 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 12785 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 12790 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOcatUpdates,_lhsOlibUpdates,_lhsOoriginalTree))) sem_Statement_Truncate :: Annotation -> T_StringList -> T_RestartIdentity -> T_Cascade -> T_Statement sem_Statement_Truncate ann_ tables_ restartIdentity_ cascade_ = (\ _lhsIcat _lhsIinProducedCat _lhsIlib -> (let _lhsOcatUpdates :: ([CatalogUpdate]) _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _lhsOannotatedTree :: Statement _lhsOoriginalTree :: Statement _tablesOcat :: Catalog _tablesOlib :: LocalIdentifierBindings _restartIdentityOcat :: Catalog _restartIdentityOlib :: LocalIdentifierBindings _cascadeOcat :: Catalog _cascadeOlib :: LocalIdentifierBindings _tablesIannotatedTree :: StringList _tablesIoriginalTree :: StringList _tablesIstrings :: ([String]) _restartIdentityIannotatedTree :: RestartIdentity _restartIdentityIoriginalTree :: RestartIdentity _cascadeIannotatedTree :: Cascade _cascadeIoriginalTree :: Cascade -- "./TypeChecking/Statements.ag"(line 89, column 9) _lhsOcatUpdates = {-# LINE 89 "./TypeChecking/Statements.ag" #-} [] {-# LINE 12822 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 90, column 9) _lhsOlibUpdates = {-# LINE 90 "./TypeChecking/Statements.ag" #-} [] {-# LINE 12827 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Truncate ann_ _tablesIannotatedTree _restartIdentityIannotatedTree _cascadeIannotatedTree {-# LINE 12832 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Truncate ann_ _tablesIoriginalTree _restartIdentityIoriginalTree _cascadeIoriginalTree {-# LINE 12837 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 12842 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 12847 "AstInternal.hs" #-} -- copy rule (down) _tablesOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 12852 "AstInternal.hs" #-} -- copy rule (down) _tablesOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 12857 "AstInternal.hs" #-} -- copy rule (down) _restartIdentityOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 12862 "AstInternal.hs" #-} -- copy rule (down) _restartIdentityOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 12867 "AstInternal.hs" #-} -- copy rule (down) _cascadeOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 12872 "AstInternal.hs" #-} -- copy rule (down) _cascadeOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 12877 "AstInternal.hs" #-} ( _tablesIannotatedTree,_tablesIoriginalTree,_tablesIstrings) = (tables_ _tablesOcat _tablesOlib ) ( _restartIdentityIannotatedTree,_restartIdentityIoriginalTree) = (restartIdentity_ _restartIdentityOcat _restartIdentityOlib ) ( _cascadeIannotatedTree,_cascadeIoriginalTree) = (cascade_ _cascadeOcat _cascadeOlib ) in ( _lhsOannotatedTree,_lhsOcatUpdates,_lhsOlibUpdates,_lhsOoriginalTree))) sem_Statement_Update :: Annotation -> String -> T_SetClauseList -> T_MaybeBoolExpression -> T_MaybeSelectList -> T_Statement sem_Statement_Update ann_ table_ assigns_ whr_ returning_ = (\ _lhsIcat _lhsIinProducedCat _lhsIlib -> (let _lhsOannotatedTree :: Statement _lhsOcatUpdates :: ([CatalogUpdate]) _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _tpe :: (Either [TypeError] Type) _assignWInferredTypes :: SetClauseList _catUpdates :: ([CatalogUpdate]) _whrOlib :: LocalIdentifierBindings _assignsOlib :: LocalIdentifierBindings _returningOlib :: LocalIdentifierBindings _lhsOoriginalTree :: Statement _assignsOcat :: Catalog _whrOcat :: Catalog _returningOcat :: Catalog _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 ++ [CatUpdates _catUpdates ]) {-# LINE 12925 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 67, column 9) _lhsOcatUpdates = {-# LINE 67 "./TypeChecking/Statements.ag" #-} _catUpdates {-# LINE 12930 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 68, column 9) _lhsOlibUpdates = {-# LINE 68 "./TypeChecking/Statements.ag" #-} _libUpdates {-# LINE 12935 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 73, column 9) _libUpdates = {-# LINE 73 "./TypeChecking/Statements.ag" #-} [] {-# LINE 12940 "AstInternal.hs" #-} -- "./TypeChecking/Dml.ag"(line 65, column 9) _tpe = {-# LINE 65 "./TypeChecking/Dml.ag" #-} do checkRelationExists _lhsIcat table_ dependsOnRTpe (map snd _assignsIpairs) $ do _columnTypes liftErrors _assignsIrowSetErrors return $ Pseudo Void {-# LINE 12950 "AstInternal.hs" #-} -- "./TypeChecking/Dml.ag"(line 72, column 9) _statementType = {-# LINE 72 "./TypeChecking/Dml.ag" #-} leftToEmpty (\ct -> [StatementType (getPlaceholderTypes _assignWInferredTypes ++ getPlaceholderTypes _whrIannotatedTree) (fromMaybe [] _returningIlistType)]) _columnTypes {-# LINE 12958 "AstInternal.hs" #-} -- "./TypeChecking/Dml.ag"(line 78, column 9) _columnTypes = {-# LINE 78 "./TypeChecking/Dml.ag" #-} checkColumnConsistency _lhsIcat table_ (map fst _assignsIpairs) _assignsIpairs {-# LINE 12966 "AstInternal.hs" #-} -- "./TypeChecking/Dml.ag"(line 84, column 9) _assignWInferredTypes = {-# LINE 84 "./TypeChecking/Dml.ag" #-} let colTypes :: [Type] colTypes = (map snd $ fromRight [] _columnTypes ) in setInferredTypesG colTypes _assignsIannotatedTree {-# LINE 12973 "AstInternal.hs" #-} -- "./TypeChecking/Dml.ag"(line 89, column 9) _backTree = {-# LINE 89 "./TypeChecking/Dml.ag" #-} Update ann_ table_ _assignWInferredTypes _whrIannotatedTree _returningIannotatedTree {-# LINE 12982 "AstInternal.hs" #-} -- "./TypeChecking/Dml.ag"(line 94, column 9) _catUpdates = {-# LINE 94 "./TypeChecking/Dml.ag" #-} [] {-# LINE 12987 "AstInternal.hs" #-} -- "./TypeChecking/Dml.ag"(line 114, column 9) _lib = {-# LINE 114 "./TypeChecking/Dml.ag" #-} fromRight _lhsIlib $ do ct <- catCompositeAttrs _lhsIcat relationComposites table_ updateBindings _lhsIlib _lhsIcat [LibStackIDs [("", ct)]] {-# LINE 12996 "AstInternal.hs" #-} -- "./TypeChecking/Dml.ag"(line 120, column 9) _whrOlib = {-# LINE 120 "./TypeChecking/Dml.ag" #-} _lib {-# LINE 13001 "AstInternal.hs" #-} -- "./TypeChecking/Dml.ag"(line 121, column 9) _assignsOlib = {-# LINE 121 "./TypeChecking/Dml.ag" #-} _lib {-# LINE 13006 "AstInternal.hs" #-} -- "./TypeChecking/Dml.ag"(line 122, column 9) _returningOlib = {-# LINE 122 "./TypeChecking/Dml.ag" #-} _lib {-# LINE 13011 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Update ann_ table_ _assignsIannotatedTree _whrIannotatedTree _returningIannotatedTree {-# LINE 13016 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Update ann_ table_ _assignsIoriginalTree _whrIoriginalTree _returningIoriginalTree {-# LINE 13021 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 13026 "AstInternal.hs" #-} -- copy rule (down) _assignsOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 13031 "AstInternal.hs" #-} -- copy rule (down) _whrOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 13036 "AstInternal.hs" #-} -- copy rule (down) _returningOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 13041 "AstInternal.hs" #-} ( _assignsIannotatedTree,_assignsIoriginalTree,_assignsIpairs,_assignsIrowSetErrors) = (assigns_ _assignsOcat _assignsOlib ) ( _whrIannotatedTree,_whrIoriginalTree) = (whr_ _whrOcat _whrOlib ) ( _returningIannotatedTree,_returningIlistType,_returningIoriginalTree) = (returning_ _returningOcat _returningOlib ) in ( _lhsOannotatedTree,_lhsOcatUpdates,_lhsOlibUpdates,_lhsOoriginalTree))) sem_Statement_WhileStatement :: Annotation -> T_Expression -> T_StatementList -> T_Statement sem_Statement_WhileStatement ann_ expr_ sts_ = (\ _lhsIcat _lhsIinProducedCat _lhsIlib -> (let _lhsOcatUpdates :: ([CatalogUpdate]) _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _stsOcatUpdates :: ([CatalogUpdate]) _stsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _lhsOannotatedTree :: Statement _lhsOoriginalTree :: Statement _exprOcat :: Catalog _exprOlib :: LocalIdentifierBindings _stsOcat :: Catalog _stsOlib :: LocalIdentifierBindings _exprIannotatedTree :: Expression _exprIliftedColumnName :: String _exprIoriginalTree :: Expression _stsIannotatedTree :: StatementList _stsIoriginalTree :: StatementList _stsIproducedCat :: Catalog _stsIproducedLib :: LocalIdentifierBindings -- "./TypeChecking/Statements.ag"(line 89, column 9) _lhsOcatUpdates = {-# LINE 89 "./TypeChecking/Statements.ag" #-} [] {-# LINE 13078 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 90, column 9) _lhsOlibUpdates = {-# LINE 90 "./TypeChecking/Statements.ag" #-} [] {-# LINE 13083 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 110, column 9) _stsOcatUpdates = {-# LINE 110 "./TypeChecking/Statements.ag" #-} [] {-# LINE 13088 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 111, column 9) _stsOlibUpdates = {-# LINE 111 "./TypeChecking/Statements.ag" #-} [] {-# LINE 13093 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} WhileStatement ann_ _exprIannotatedTree _stsIannotatedTree {-# LINE 13098 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} WhileStatement ann_ _exprIoriginalTree _stsIoriginalTree {-# LINE 13103 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 13108 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 13113 "AstInternal.hs" #-} -- copy rule (down) _exprOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 13118 "AstInternal.hs" #-} -- copy rule (down) _exprOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 13123 "AstInternal.hs" #-} -- copy rule (down) _stsOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 13128 "AstInternal.hs" #-} -- copy rule (down) _stsOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 13133 "AstInternal.hs" #-} ( _exprIannotatedTree,_exprIliftedColumnName,_exprIoriginalTree) = (expr_ _exprOcat _exprOlib ) ( _stsIannotatedTree,_stsIoriginalTree,_stsIproducedCat,_stsIproducedLib) = (sts_ _stsOcat _stsOcatUpdates _stsOlib _stsOlibUpdates ) in ( _lhsOannotatedTree,_lhsOcatUpdates,_lhsOlibUpdates,_lhsOoriginalTree))) -- StatementList ----------------------------------------------- {- visit 0: inherited attributes: cat : Catalog catUpdates : [CatalogUpdate] lib : LocalIdentifierBindings libUpdates : [LocalIdentifierBindingsUpdate] synthesized attributes: annotatedTree : SELF originalTree : SELF producedCat : Catalog producedLib : LocalIdentifierBindings alternatives: alternative Cons: child hd : Statement child tl : StatementList visit 0: local newCat : _ local newLib : _ local annotatedTree : _ local originalTree : _ alternative Nil: visit 0: local newCat : _ 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 = Catalog -> ([CatalogUpdate]) -> LocalIdentifierBindings -> ([LocalIdentifierBindingsUpdate]) -> ( StatementList,StatementList,Catalog,LocalIdentifierBindings) data Inh_StatementList = Inh_StatementList {cat_Inh_StatementList :: Catalog,catUpdates_Inh_StatementList :: [CatalogUpdate],lib_Inh_StatementList :: LocalIdentifierBindings,libUpdates_Inh_StatementList :: [LocalIdentifierBindingsUpdate]} data Syn_StatementList = Syn_StatementList {annotatedTree_Syn_StatementList :: StatementList,originalTree_Syn_StatementList :: StatementList,producedCat_Syn_StatementList :: Catalog,producedLib_Syn_StatementList :: LocalIdentifierBindings} wrap_StatementList :: T_StatementList -> Inh_StatementList -> Syn_StatementList wrap_StatementList sem (Inh_StatementList _lhsIcat _lhsIcatUpdates _lhsIlib _lhsIlibUpdates ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree,_lhsOproducedCat,_lhsOproducedLib) = (sem _lhsIcat _lhsIcatUpdates _lhsIlib _lhsIlibUpdates ) in (Syn_StatementList _lhsOannotatedTree _lhsOoriginalTree _lhsOproducedCat _lhsOproducedLib )) sem_StatementList_Cons :: T_Statement -> T_StatementList -> T_StatementList sem_StatementList_Cons hd_ tl_ = (\ _lhsIcat _lhsIcatUpdates _lhsIlib _lhsIlibUpdates -> (let _hdOcat :: Catalog _tlOcat :: Catalog _hdOlib :: LocalIdentifierBindings _tlOlib :: LocalIdentifierBindings _lhsOproducedCat :: Catalog _lhsOproducedLib :: LocalIdentifierBindings _tlOcatUpdates :: ([CatalogUpdate]) _tlOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _hdOinProducedCat :: Catalog _lhsOannotatedTree :: StatementList _lhsOoriginalTree :: StatementList _hdIannotatedTree :: Statement _hdIcatUpdates :: ([CatalogUpdate]) _hdIlibUpdates :: ([LocalIdentifierBindingsUpdate]) _hdIoriginalTree :: Statement _tlIannotatedTree :: StatementList _tlIoriginalTree :: StatementList _tlIproducedCat :: Catalog _tlIproducedLib :: LocalIdentifierBindings -- "./TypeChecking/Statements.ag"(line 36, column 9) _newCat = {-# LINE 36 "./TypeChecking/Statements.ag" #-} fromRight _lhsIcat $ updateCatalog _lhsIcat _lhsIcatUpdates {-# LINE 13220 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 37, column 9) _newLib = {-# LINE 37 "./TypeChecking/Statements.ag" #-} fromRight _lhsIlib $ updateBindings _lhsIlib _lhsIcat _lhsIlibUpdates {-# LINE 13225 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 39, column 9) _hdOcat = {-# LINE 39 "./TypeChecking/Statements.ag" #-} _newCat {-# LINE 13230 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 40, column 9) _tlOcat = {-# LINE 40 "./TypeChecking/Statements.ag" #-} _newCat {-# LINE 13235 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 41, column 9) _hdOlib = {-# LINE 41 "./TypeChecking/Statements.ag" #-} _newLib {-# LINE 13240 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 42, column 9) _tlOlib = {-# LINE 42 "./TypeChecking/Statements.ag" #-} _newLib {-# LINE 13245 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 46, column 9) _lhsOproducedCat = {-# LINE 46 "./TypeChecking/Statements.ag" #-} _tlIproducedCat {-# LINE 13250 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 47, column 9) _lhsOproducedLib = {-# LINE 47 "./TypeChecking/Statements.ag" #-} _tlIproducedLib {-# LINE 13255 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 50, column 9) _tlOcatUpdates = {-# LINE 50 "./TypeChecking/Statements.ag" #-} _hdIcatUpdates {-# LINE 13260 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 51, column 9) _tlOlibUpdates = {-# LINE 51 "./TypeChecking/Statements.ag" #-} _hdIlibUpdates {-# LINE 13265 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 76, column 12) _hdOinProducedCat = {-# LINE 76 "./TypeChecking/Statements.ag" #-} _tlIproducedCat {-# LINE 13270 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} (:) _hdIannotatedTree _tlIannotatedTree {-# LINE 13275 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} (:) _hdIoriginalTree _tlIoriginalTree {-# LINE 13280 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 13285 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 13290 "AstInternal.hs" #-} ( _hdIannotatedTree,_hdIcatUpdates,_hdIlibUpdates,_hdIoriginalTree) = (hd_ _hdOcat _hdOinProducedCat _hdOlib ) ( _tlIannotatedTree,_tlIoriginalTree,_tlIproducedCat,_tlIproducedLib) = (tl_ _tlOcat _tlOcatUpdates _tlOlib _tlOlibUpdates ) in ( _lhsOannotatedTree,_lhsOoriginalTree,_lhsOproducedCat,_lhsOproducedLib))) sem_StatementList_Nil :: T_StatementList sem_StatementList_Nil = (\ _lhsIcat _lhsIcatUpdates _lhsIlib _lhsIlibUpdates -> (let _lhsOproducedCat :: Catalog _lhsOproducedLib :: LocalIdentifierBindings _lhsOannotatedTree :: StatementList _lhsOoriginalTree :: StatementList -- "./TypeChecking/Statements.ag"(line 36, column 9) _newCat = {-# LINE 36 "./TypeChecking/Statements.ag" #-} fromRight _lhsIcat $ updateCatalog _lhsIcat _lhsIcatUpdates {-# LINE 13310 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 37, column 9) _newLib = {-# LINE 37 "./TypeChecking/Statements.ag" #-} fromRight _lhsIlib $ updateBindings _lhsIlib _lhsIcat _lhsIlibUpdates {-# LINE 13315 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 53, column 9) _lhsOproducedCat = {-# LINE 53 "./TypeChecking/Statements.ag" #-} _newCat {-# LINE 13320 "AstInternal.hs" #-} -- "./TypeChecking/Statements.ag"(line 54, column 9) _lhsOproducedLib = {-# LINE 54 "./TypeChecking/Statements.ag" #-} _newLib {-# LINE 13325 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 13330 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 13335 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 13340 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 13345 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree,_lhsOproducedCat,_lhsOproducedLib))) -- StringList -------------------------------------------------- {- visit 0: inherited attributes: cat : Catalog 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 = Catalog -> LocalIdentifierBindings -> ( StringList,StringList,([String])) data Inh_StringList = Inh_StringList {cat_Inh_StringList :: Catalog,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 _lhsIcat _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree,_lhsOstrings) = (sem _lhsIcat _lhsIlib ) in (Syn_StringList _lhsOannotatedTree _lhsOoriginalTree _lhsOstrings )) sem_StringList_Cons :: String -> T_StringList -> T_StringList sem_StringList_Cons hd_ tl_ = (\ _lhsIcat _lhsIlib -> (let _lhsOstrings :: ([String]) _lhsOannotatedTree :: StringList _lhsOoriginalTree :: StringList _tlOcat :: Catalog _tlOlib :: LocalIdentifierBindings _tlIannotatedTree :: StringList _tlIoriginalTree :: StringList _tlIstrings :: ([String]) -- "./TypeChecking/Misc.ag"(line 67, column 10) _lhsOstrings = {-# LINE 67 "./TypeChecking/Misc.ag" #-} hd_ : _tlIstrings {-# LINE 13406 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} (:) hd_ _tlIannotatedTree {-# LINE 13411 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} (:) hd_ _tlIoriginalTree {-# LINE 13416 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 13421 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 13426 "AstInternal.hs" #-} -- copy rule (down) _tlOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 13431 "AstInternal.hs" #-} -- copy rule (down) _tlOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 13436 "AstInternal.hs" #-} ( _tlIannotatedTree,_tlIoriginalTree,_tlIstrings) = (tl_ _tlOcat _tlOlib ) in ( _lhsOannotatedTree,_lhsOoriginalTree,_lhsOstrings))) sem_StringList_Nil :: T_StringList sem_StringList_Nil = (\ _lhsIcat _lhsIlib -> (let _lhsOstrings :: ([String]) _lhsOannotatedTree :: StringList _lhsOoriginalTree :: StringList -- "./TypeChecking/Misc.ag"(line 68, column 9) _lhsOstrings = {-# LINE 68 "./TypeChecking/Misc.ag" #-} [] {-# LINE 13451 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 13456 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 13461 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 13466 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 13471 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree,_lhsOstrings))) -- StringTypeNameListPair -------------------------------------- {- visit 0: inherited attributes: cat : Catalog 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 = Catalog -> LocalIdentifierBindings -> ( StringTypeNameListPair,((String,[Type])),StringTypeNameListPair) data Inh_StringTypeNameListPair = Inh_StringTypeNameListPair {cat_Inh_StringTypeNameListPair :: Catalog,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 _lhsIcat _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOfnSig,_lhsOoriginalTree) = (sem _lhsIcat _lhsIlib ) in (Syn_StringTypeNameListPair _lhsOannotatedTree _lhsOfnSig _lhsOoriginalTree )) sem_StringTypeNameListPair_Tuple :: String -> T_TypeNameList -> T_StringTypeNameListPair sem_StringTypeNameListPair_Tuple x1_ x2_ = (\ _lhsIcat _lhsIlib -> (let _lhsOfnSig :: ((String,[Type])) _lhsOannotatedTree :: StringTypeNameListPair _lhsOoriginalTree :: StringTypeNameListPair _x2Ocat :: Catalog _x2Olib :: LocalIdentifierBindings _x2IannotatedTree :: TypeNameList _x2InamedTypes :: ([Type]) _x2IoriginalTree :: TypeNameList -- "./TypeChecking/Drops.ag"(line 25, column 13) _lhsOfnSig = {-# LINE 25 "./TypeChecking/Drops.ag" #-} (x1_, _x2InamedTypes) {-# LINE 13528 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} (x1_,_x2IannotatedTree) {-# LINE 13533 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} (x1_,_x2IoriginalTree) {-# LINE 13538 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 13543 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 13548 "AstInternal.hs" #-} -- copy rule (down) _x2Ocat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 13553 "AstInternal.hs" #-} -- copy rule (down) _x2Olib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 13558 "AstInternal.hs" #-} ( _x2IannotatedTree,_x2InamedTypes,_x2IoriginalTree) = (x2_ _x2Ocat _x2Olib ) in ( _lhsOannotatedTree,_lhsOfnSig,_lhsOoriginalTree))) -- StringTypeNameListPairList ---------------------------------- {- visit 0: inherited attributes: cat : Catalog 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 = Catalog -> LocalIdentifierBindings -> ( StringTypeNameListPairList,([(String,[Type])]),StringTypeNameListPairList) data Inh_StringTypeNameListPairList = Inh_StringTypeNameListPairList {cat_Inh_StringTypeNameListPairList :: Catalog,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 _lhsIcat _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOfnSigs,_lhsOoriginalTree) = (sem _lhsIcat _lhsIlib ) in (Syn_StringTypeNameListPairList _lhsOannotatedTree _lhsOfnSigs _lhsOoriginalTree )) sem_StringTypeNameListPairList_Cons :: T_StringTypeNameListPair -> T_StringTypeNameListPairList -> T_StringTypeNameListPairList sem_StringTypeNameListPairList_Cons hd_ tl_ = (\ _lhsIcat _lhsIlib -> (let _lhsOfnSigs :: ([(String,[Type])]) _lhsOannotatedTree :: StringTypeNameListPairList _lhsOoriginalTree :: StringTypeNameListPairList _hdOcat :: Catalog _hdOlib :: LocalIdentifierBindings _tlOcat :: Catalog _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 13626 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} (:) _hdIannotatedTree _tlIannotatedTree {-# LINE 13631 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} (:) _hdIoriginalTree _tlIoriginalTree {-# LINE 13636 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 13641 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 13646 "AstInternal.hs" #-} -- copy rule (down) _hdOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 13651 "AstInternal.hs" #-} -- copy rule (down) _hdOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 13656 "AstInternal.hs" #-} -- copy rule (down) _tlOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 13661 "AstInternal.hs" #-} -- copy rule (down) _tlOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 13666 "AstInternal.hs" #-} ( _hdIannotatedTree,_hdIfnSig,_hdIoriginalTree) = (hd_ _hdOcat _hdOlib ) ( _tlIannotatedTree,_tlIfnSigs,_tlIoriginalTree) = (tl_ _tlOcat _tlOlib ) in ( _lhsOannotatedTree,_lhsOfnSigs,_lhsOoriginalTree))) sem_StringTypeNameListPairList_Nil :: T_StringTypeNameListPairList sem_StringTypeNameListPairList_Nil = (\ _lhsIcat _lhsIlib -> (let _lhsOfnSigs :: ([(String,[Type])]) _lhsOannotatedTree :: StringTypeNameListPairList _lhsOoriginalTree :: StringTypeNameListPairList -- "./TypeChecking/Drops.ag"(line 21, column 11) _lhsOfnSigs = {-# LINE 21 "./TypeChecking/Drops.ag" #-} [] {-# LINE 13683 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 13688 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 13693 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 13698 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 13703 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOfnSigs,_lhsOoriginalTree))) -- TableAlias -------------------------------------------------- {- visit 0: inherited attributes: cat : Catalog 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 = Catalog -> LocalIdentifierBindings -> ( TableAlias,TableAlias) data Inh_TableAlias = Inh_TableAlias {cat_Inh_TableAlias :: Catalog,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 _lhsIcat _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIcat _lhsIlib ) in (Syn_TableAlias _lhsOannotatedTree _lhsOoriginalTree )) sem_TableAlias_FullAlias :: String -> ([String]) -> T_TableAlias sem_TableAlias_FullAlias alias_ cols_ = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: TableAlias _lhsOoriginalTree :: TableAlias -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} FullAlias alias_ cols_ {-# LINE 13769 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} FullAlias alias_ cols_ {-# LINE 13774 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 13779 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 13784 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_TableAlias_NoAlias :: T_TableAlias sem_TableAlias_NoAlias = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: TableAlias _lhsOoriginalTree :: TableAlias -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} NoAlias {-# LINE 13796 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} NoAlias {-# LINE 13801 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 13806 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 13811 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_TableAlias_TableAlias :: String -> T_TableAlias sem_TableAlias_TableAlias alias_ = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: TableAlias _lhsOoriginalTree :: TableAlias -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} TableAlias alias_ {-# LINE 13824 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} TableAlias alias_ {-# LINE 13829 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 13834 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 13839 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) -- TableRef ---------------------------------------------------- {- visit 0: inherited attributes: cat : Catalog 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 = Catalog -> ([LocalIdentifierBindingsUpdate]) -> LocalIdentifierBindings -> ( TableRef,([(String,Type)]),([LocalIdentifierBindingsUpdate]),TableRef,([(String,[(String,Type)])]),([(String,[(String,Type)])]),([(String,Type)])) data Inh_TableRef = Inh_TableRef {cat_Inh_TableRef :: Catalog,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 _lhsIcat _lhsIjlibUpdates _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOidLookups,_lhsOlibUpdates,_lhsOoriginalTree,_lhsOqidLookups,_lhsOqstarExpansion,_lhsOstarExpansion) = (sem _lhsIcat _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_ = (\ _lhsIcat _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 _tblOcat :: Catalog _tblOlib :: LocalIdentifierBindings _natOcat :: Catalog _natOlib :: LocalIdentifierBindings _joinTypeOcat :: Catalog _joinTypeOlib :: LocalIdentifierBindings _tbl1Ocat :: Catalog _tbl1Olib :: LocalIdentifierBindings _onExprOcat :: Catalog _aliasOcat :: Catalog _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 14028 "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 14036 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 135, column 9) _errs = {-# LINE 135 "./TypeChecking/TableRefs.ag" #-} fromLeft [] _ejoinAttrs {-# LINE 14041 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 136, column 9) _removeJoinAttrs = {-# LINE 136 "./TypeChecking/TableRefs.ag" #-} filter (\(n,_) -> n `notElem` _joinNames ) {-# LINE 14046 "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 _lhsIcat [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 14068 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 170, column 9) _joinNames = {-# LINE 170 "./TypeChecking/TableRefs.ag" #-} map fst _joinAttrs {-# LINE 14073 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 171, column 9) _joinAttrs = {-# LINE 171 "./TypeChecking/TableRefs.ag" #-} fromRight [] _ejoinAttrs {-# LINE 14078 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 176, column 9) _idLookups = {-# LINE 176 "./TypeChecking/TableRefs.ag" #-} _joinAttrs ++ _removeJoinAttrs _tblIidLookups ++ _removeJoinAttrs _tbl1IidLookups {-# LINE 14085 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 179, column 9) _qidLookups = {-# LINE 179 "./TypeChecking/TableRefs.ag" #-} _tblIqidLookups ++ _tbl1IqidLookups {-# LINE 14090 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 180, column 9) _starExpansion = {-# LINE 180 "./TypeChecking/TableRefs.ag" #-} _joinAttrs ++ _removeJoinAttrs _tblIstarExpansion ++ _removeJoinAttrs _tbl1IstarExpansion {-# LINE 14097 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 183, column 9) _qstarExpansion = {-# LINE 183 "./TypeChecking/TableRefs.ag" #-} _tblIqstarExpansion ++ _tbl1IqstarExpansion {-# LINE 14102 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 187, column 9) _newLib = {-# LINE 187 "./TypeChecking/TableRefs.ag" #-} case updateBindings _lhsIlib _lhsIcat (_libUpdates ++ _lhsIjlibUpdates) of Left x -> error $ show x Right e -> e {-# LINE 14109 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 190, column 9) _onExprOlib = {-# LINE 190 "./TypeChecking/TableRefs.ag" #-} _newLib {-# LINE 14114 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 192, column 9) _tblOjlibUpdates = {-# LINE 192 "./TypeChecking/TableRefs.ag" #-} _libUpdates {-# LINE 14119 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 193, column 9) _tbl1OjlibUpdates = {-# LINE 193 "./TypeChecking/TableRefs.ag" #-} _libUpdates {-# LINE 14124 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 248, column 9) _lhsOlibUpdates = {-# LINE 248 "./TypeChecking/TableRefs.ag" #-} _libUpdates {-# LINE 14129 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 249, column 9) _lhsOidLookups = {-# LINE 249 "./TypeChecking/TableRefs.ag" #-} _idLookups {-# LINE 14134 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 250, column 9) _lhsOqidLookups = {-# LINE 250 "./TypeChecking/TableRefs.ag" #-} _qidLookups {-# LINE 14139 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 251, column 9) _lhsOstarExpansion = {-# LINE 251 "./TypeChecking/TableRefs.ag" #-} _starExpansion {-# LINE 14144 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 252, column 9) _lhsOqstarExpansion = {-# LINE 252 "./TypeChecking/TableRefs.ag" #-} _qstarExpansion {-# LINE 14149 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 264, column 9) _backTree = {-# LINE 264 "./TypeChecking/TableRefs.ag" #-} JoinedTref ann_ _tblIannotatedTree _natIannotatedTree _joinTypeIannotatedTree _tbl1IannotatedTree _onExprIannotatedTree _aliasIannotatedTree {-# LINE 14160 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} JoinedTref ann_ _tblIannotatedTree _natIannotatedTree _joinTypeIannotatedTree _tbl1IannotatedTree _onExprIannotatedTree _aliasIannotatedTree {-# LINE 14165 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} JoinedTref ann_ _tblIoriginalTree _natIoriginalTree _joinTypeIoriginalTree _tbl1IoriginalTree _onExprIoriginalTree _aliasIoriginalTree {-# LINE 14170 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 14175 "AstInternal.hs" #-} -- copy rule (down) _tblOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 14180 "AstInternal.hs" #-} -- copy rule (down) _tblOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 14185 "AstInternal.hs" #-} -- copy rule (down) _natOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 14190 "AstInternal.hs" #-} -- copy rule (down) _natOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 14195 "AstInternal.hs" #-} -- copy rule (down) _joinTypeOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 14200 "AstInternal.hs" #-} -- copy rule (down) _joinTypeOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 14205 "AstInternal.hs" #-} -- copy rule (down) _tbl1Ocat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 14210 "AstInternal.hs" #-} -- copy rule (down) _tbl1Olib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 14215 "AstInternal.hs" #-} -- copy rule (down) _onExprOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 14220 "AstInternal.hs" #-} -- copy rule (down) _aliasOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 14225 "AstInternal.hs" #-} -- copy rule (down) _aliasOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 14230 "AstInternal.hs" #-} ( _tblIannotatedTree,_tblIidLookups,_tblIlibUpdates,_tblIoriginalTree,_tblIqidLookups,_tblIqstarExpansion,_tblIstarExpansion) = (tbl_ _tblOcat _tblOjlibUpdates _tblOlib ) ( _natIannotatedTree,_natIoriginalTree) = (nat_ _natOcat _natOlib ) ( _joinTypeIannotatedTree,_joinTypeIoriginalTree) = (joinType_ _joinTypeOcat _joinTypeOlib ) ( _tbl1IannotatedTree,_tbl1IidLookups,_tbl1IlibUpdates,_tbl1IoriginalTree,_tbl1IqidLookups,_tbl1IqstarExpansion,_tbl1IstarExpansion) = (tbl1_ _tbl1Ocat _tbl1OjlibUpdates _tbl1Olib ) ( _onExprIannotatedTree,_onExprIoriginalTree) = (onExpr_ _onExprOcat _onExprOlib ) ( _aliasIannotatedTree,_aliasIoriginalTree) = (alias_ _aliasOcat _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_ = (\ _lhsIcat _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 _selOcat :: Catalog _selOlib :: LocalIdentifierBindings _aliasOcat :: Catalog _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 14277 "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 14285 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 92, column 9) _errs = {-# LINE 92 "./TypeChecking/TableRefs.ag" #-} case _selectAttrs of Left e -> e Right _ -> [] {-# LINE 14292 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 96, column 9) _selectAttrs = {-# LINE 96 "./TypeChecking/TableRefs.ag" #-} unwrapSetOfComposite (getTypeAnnotation _selIannotatedTree) {-# LINE 14297 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 98, column 9) _idLookups = {-# LINE 98 "./TypeChecking/TableRefs.ag" #-} fromRight [] _selectAttrs {-# LINE 14302 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 99, column 9) _qidLookups = {-# LINE 99 "./TypeChecking/TableRefs.ag" #-} [(getAlias "" _aliasIannotatedTree, _idLookups )] {-# LINE 14307 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 100, column 9) _starExpansion = {-# LINE 100 "./TypeChecking/TableRefs.ag" #-} _idLookups {-# LINE 14312 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 101, column 9) _qstarExpansion = {-# LINE 101 "./TypeChecking/TableRefs.ag" #-} _qidLookups {-# LINE 14317 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 248, column 9) _lhsOlibUpdates = {-# LINE 248 "./TypeChecking/TableRefs.ag" #-} _libUpdates {-# LINE 14322 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 249, column 9) _lhsOidLookups = {-# LINE 249 "./TypeChecking/TableRefs.ag" #-} _idLookups {-# LINE 14327 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 250, column 9) _lhsOqidLookups = {-# LINE 250 "./TypeChecking/TableRefs.ag" #-} _qidLookups {-# LINE 14332 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 251, column 9) _lhsOstarExpansion = {-# LINE 251 "./TypeChecking/TableRefs.ag" #-} _starExpansion {-# LINE 14337 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 252, column 9) _lhsOqstarExpansion = {-# LINE 252 "./TypeChecking/TableRefs.ag" #-} _qstarExpansion {-# LINE 14342 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 258, column 9) _backTree = {-# LINE 258 "./TypeChecking/TableRefs.ag" #-} SubTref ann_ _selIannotatedTree _aliasIannotatedTree {-# LINE 14347 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} SubTref ann_ _selIannotatedTree _aliasIannotatedTree {-# LINE 14352 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} SubTref ann_ _selIoriginalTree _aliasIoriginalTree {-# LINE 14357 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 14362 "AstInternal.hs" #-} -- copy rule (down) _selOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 14367 "AstInternal.hs" #-} -- copy rule (down) _selOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 14372 "AstInternal.hs" #-} -- copy rule (down) _aliasOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 14377 "AstInternal.hs" #-} -- copy rule (down) _aliasOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 14382 "AstInternal.hs" #-} ( _selIannotatedTree,_selIlibUpdates,_selIoriginalTree) = (sel_ _selOcat _selOlib ) ( _aliasIannotatedTree,_aliasIoriginalTree) = (alias_ _aliasOcat _aliasOlib ) in ( _lhsOannotatedTree,_lhsOidLookups,_lhsOlibUpdates,_lhsOoriginalTree,_lhsOqidLookups,_lhsOqstarExpansion,_lhsOstarExpansion))) sem_TableRef_Tref :: Annotation -> String -> T_TableAlias -> T_TableRef sem_TableRef_Tref ann_ tbl_ alias_ = (\ _lhsIcat _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 _aliasOcat :: Catalog _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 14416 "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 14424 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 104, column 9) _errs = {-# LINE 104 "./TypeChecking/TableRefs.ag" #-} case _relType of Left e -> e Right _ -> [] {-# LINE 14431 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 108, column 9) _relType = {-# LINE 108 "./TypeChecking/TableRefs.ag" #-} catCompositeAttrsPair _lhsIcat [] tbl_ {-# LINE 14436 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 109, column 9) _relType1 = {-# LINE 109 "./TypeChecking/TableRefs.ag" #-} fromRight ([],[]) _relType {-# LINE 14441 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 110, column 9) _pAttrs = {-# LINE 110 "./TypeChecking/TableRefs.ag" #-} fst _relType1 {-# LINE 14446 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 111, column 9) _sAttrs = {-# LINE 111 "./TypeChecking/TableRefs.ag" #-} snd _relType1 {-# LINE 14451 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 113, column 9) _idLookups = {-# LINE 113 "./TypeChecking/TableRefs.ag" #-} _pAttrs ++ _sAttrs {-# LINE 14456 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 114, column 9) _alias = {-# LINE 114 "./TypeChecking/TableRefs.ag" #-} getAlias tbl_ _aliasIannotatedTree {-# LINE 14461 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 115, column 9) _qidLookups = {-# LINE 115 "./TypeChecking/TableRefs.ag" #-} [(_alias , _idLookups )] {-# LINE 14466 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 116, column 9) _starExpansion = {-# LINE 116 "./TypeChecking/TableRefs.ag" #-} _pAttrs {-# LINE 14471 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 117, column 9) _qstarExpansion = {-# LINE 117 "./TypeChecking/TableRefs.ag" #-} [(_alias , _pAttrs )] {-# LINE 14476 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 248, column 9) _lhsOlibUpdates = {-# LINE 248 "./TypeChecking/TableRefs.ag" #-} _libUpdates {-# LINE 14481 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 249, column 9) _lhsOidLookups = {-# LINE 249 "./TypeChecking/TableRefs.ag" #-} _idLookups {-# LINE 14486 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 250, column 9) _lhsOqidLookups = {-# LINE 250 "./TypeChecking/TableRefs.ag" #-} _qidLookups {-# LINE 14491 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 251, column 9) _lhsOstarExpansion = {-# LINE 251 "./TypeChecking/TableRefs.ag" #-} _starExpansion {-# LINE 14496 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 252, column 9) _lhsOqstarExpansion = {-# LINE 252 "./TypeChecking/TableRefs.ag" #-} _qstarExpansion {-# LINE 14501 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 260, column 9) _backTree = {-# LINE 260 "./TypeChecking/TableRefs.ag" #-} Tref ann_ tbl_ _aliasIannotatedTree {-# LINE 14506 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Tref ann_ tbl_ _aliasIannotatedTree {-# LINE 14511 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Tref ann_ tbl_ _aliasIoriginalTree {-# LINE 14516 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 14521 "AstInternal.hs" #-} -- copy rule (down) _aliasOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 14526 "AstInternal.hs" #-} -- copy rule (down) _aliasOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 14531 "AstInternal.hs" #-} ( _aliasIannotatedTree,_aliasIoriginalTree) = (alias_ _aliasOcat _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_ = (\ _lhsIcat _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 _fnOcat :: Catalog _fnOlib :: LocalIdentifierBindings _aliasOcat :: Catalog _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 14568 "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 14576 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 120, column 9) _errs = {-# LINE 120 "./TypeChecking/TableRefs.ag" #-} case _eqfunIdens of Left e -> e Right _ -> [] {-# LINE 14583 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 124, column 9) _eqfunIdens = {-# LINE 124 "./TypeChecking/TableRefs.ag" #-} funIdens _lhsIcat _alias _fnIannotatedTree {-# LINE 14588 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 125, column 9) _qfunIdens = {-# LINE 125 "./TypeChecking/TableRefs.ag" #-} fromRight ("",[]) _eqfunIdens {-# LINE 14593 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 126, column 9) _alias2 = {-# LINE 126 "./TypeChecking/TableRefs.ag" #-} fst _qfunIdens {-# LINE 14598 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 127, column 9) _funIdens = {-# LINE 127 "./TypeChecking/TableRefs.ag" #-} snd _qfunIdens {-# LINE 14603 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 128, column 9) _alias = {-# LINE 128 "./TypeChecking/TableRefs.ag" #-} getAlias "" _aliasIannotatedTree {-# LINE 14608 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 130, column 9) _idLookups = {-# LINE 130 "./TypeChecking/TableRefs.ag" #-} _funIdens {-# LINE 14613 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 131, column 9) _qidLookups = {-# LINE 131 "./TypeChecking/TableRefs.ag" #-} [(_alias2, _idLookups )] {-# LINE 14618 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 132, column 9) _starExpansion = {-# LINE 132 "./TypeChecking/TableRefs.ag" #-} _idLookups {-# LINE 14623 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 133, column 9) _qstarExpansion = {-# LINE 133 "./TypeChecking/TableRefs.ag" #-} _qidLookups {-# LINE 14628 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 248, column 9) _lhsOlibUpdates = {-# LINE 248 "./TypeChecking/TableRefs.ag" #-} _libUpdates {-# LINE 14633 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 249, column 9) _lhsOidLookups = {-# LINE 249 "./TypeChecking/TableRefs.ag" #-} _idLookups {-# LINE 14638 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 250, column 9) _lhsOqidLookups = {-# LINE 250 "./TypeChecking/TableRefs.ag" #-} _qidLookups {-# LINE 14643 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 251, column 9) _lhsOstarExpansion = {-# LINE 251 "./TypeChecking/TableRefs.ag" #-} _starExpansion {-# LINE 14648 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 252, column 9) _lhsOqstarExpansion = {-# LINE 252 "./TypeChecking/TableRefs.ag" #-} _qstarExpansion {-# LINE 14653 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 262, column 9) _backTree = {-# LINE 262 "./TypeChecking/TableRefs.ag" #-} TrefFun ann_ _fnIannotatedTree _aliasIannotatedTree {-# LINE 14658 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} TrefFun ann_ _fnIannotatedTree _aliasIannotatedTree {-# LINE 14663 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} TrefFun ann_ _fnIoriginalTree _aliasIoriginalTree {-# LINE 14668 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 14673 "AstInternal.hs" #-} -- copy rule (down) _fnOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 14678 "AstInternal.hs" #-} -- copy rule (down) _fnOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 14683 "AstInternal.hs" #-} -- copy rule (down) _aliasOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 14688 "AstInternal.hs" #-} -- copy rule (down) _aliasOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 14693 "AstInternal.hs" #-} ( _fnIannotatedTree,_fnIliftedColumnName,_fnIoriginalTree) = (fn_ _fnOcat _fnOlib ) ( _aliasIannotatedTree,_aliasIoriginalTree) = (alias_ _aliasOcat _aliasOlib ) in ( _lhsOannotatedTree,_lhsOidLookups,_lhsOlibUpdates,_lhsOoriginalTree,_lhsOqidLookups,_lhsOqstarExpansion,_lhsOstarExpansion))) -- TableRefList ------------------------------------------------ {- visit 0: inherited attributes: cat : Catalog 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 = Catalog -> LocalIdentifierBindings -> ( TableRefList,([LocalIdentifierBindingsUpdate]),TableRefList) data Inh_TableRefList = Inh_TableRefList {cat_Inh_TableRefList :: Catalog,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 _lhsIcat _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOlibUpdates,_lhsOoriginalTree) = (sem _lhsIcat _lhsIlib ) in (Syn_TableRefList _lhsOannotatedTree _lhsOlibUpdates _lhsOoriginalTree )) sem_TableRefList_Cons :: T_TableRef -> T_TableRefList -> T_TableRefList sem_TableRefList_Cons hd_ tl_ = (\ _lhsIcat _lhsIlib -> (let _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _hdOjlibUpdates :: ([LocalIdentifierBindingsUpdate]) _lhsOannotatedTree :: TableRefList _lhsOoriginalTree :: TableRefList _hdOcat :: Catalog _hdOlib :: LocalIdentifierBindings _tlOcat :: Catalog _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 14768 "AstInternal.hs" #-} -- "./TypeChecking/TableRefs.ag"(line 197, column 12) _hdOjlibUpdates = {-# LINE 197 "./TypeChecking/TableRefs.ag" #-} [] {-# LINE 14773 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} (:) _hdIannotatedTree _tlIannotatedTree {-# LINE 14778 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} (:) _hdIoriginalTree _tlIoriginalTree {-# LINE 14783 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 14788 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 14793 "AstInternal.hs" #-} -- copy rule (down) _hdOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 14798 "AstInternal.hs" #-} -- copy rule (down) _hdOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 14803 "AstInternal.hs" #-} -- copy rule (down) _tlOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 14808 "AstInternal.hs" #-} -- copy rule (down) _tlOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 14813 "AstInternal.hs" #-} ( _hdIannotatedTree,_hdIidLookups,_hdIlibUpdates,_hdIoriginalTree,_hdIqidLookups,_hdIqstarExpansion,_hdIstarExpansion) = (hd_ _hdOcat _hdOjlibUpdates _hdOlib ) ( _tlIannotatedTree,_tlIlibUpdates,_tlIoriginalTree) = (tl_ _tlOcat _tlOlib ) in ( _lhsOannotatedTree,_lhsOlibUpdates,_lhsOoriginalTree))) sem_TableRefList_Nil :: T_TableRefList sem_TableRefList_Nil = (\ _lhsIcat _lhsIlib -> (let _lhsOlibUpdates :: ([LocalIdentifierBindingsUpdate]) _lhsOannotatedTree :: TableRefList _lhsOoriginalTree :: TableRefList -- "./TypeChecking/TableRefs.ag"(line 38, column 9) _lhsOlibUpdates = {-# LINE 38 "./TypeChecking/TableRefs.ag" #-} [] {-# LINE 14830 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 14835 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 14840 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 14845 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 14850 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOlibUpdates,_lhsOoriginalTree))) -- TriggerEvent ------------------------------------------------ {- visit 0: inherited attributes: cat : Catalog 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 = Catalog -> LocalIdentifierBindings -> ( TriggerEvent,TriggerEvent) data Inh_TriggerEvent = Inh_TriggerEvent {cat_Inh_TriggerEvent :: Catalog,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 _lhsIcat _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIcat _lhsIlib ) in (Syn_TriggerEvent _lhsOannotatedTree _lhsOoriginalTree )) sem_TriggerEvent_TDelete :: T_TriggerEvent sem_TriggerEvent_TDelete = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: TriggerEvent _lhsOoriginalTree :: TriggerEvent -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} TDelete {-# LINE 14911 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} TDelete {-# LINE 14916 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 14921 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 14926 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_TriggerEvent_TInsert :: T_TriggerEvent sem_TriggerEvent_TInsert = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: TriggerEvent _lhsOoriginalTree :: TriggerEvent -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} TInsert {-# LINE 14938 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} TInsert {-# LINE 14943 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 14948 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 14953 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_TriggerEvent_TUpdate :: T_TriggerEvent sem_TriggerEvent_TUpdate = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: TriggerEvent _lhsOoriginalTree :: TriggerEvent -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} TUpdate {-# LINE 14965 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} TUpdate {-# LINE 14970 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 14975 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 14980 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) -- TriggerFire ------------------------------------------------- {- visit 0: inherited attributes: cat : Catalog 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 = Catalog -> LocalIdentifierBindings -> ( TriggerFire,TriggerFire) data Inh_TriggerFire = Inh_TriggerFire {cat_Inh_TriggerFire :: Catalog,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 _lhsIcat _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIcat _lhsIlib ) in (Syn_TriggerFire _lhsOannotatedTree _lhsOoriginalTree )) sem_TriggerFire_EachRow :: T_TriggerFire sem_TriggerFire_EachRow = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: TriggerFire _lhsOoriginalTree :: TriggerFire -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} EachRow {-# LINE 15034 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} EachRow {-# LINE 15039 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 15044 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 15049 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_TriggerFire_EachStatement :: T_TriggerFire sem_TriggerFire_EachStatement = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: TriggerFire _lhsOoriginalTree :: TriggerFire -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} EachStatement {-# LINE 15061 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} EachStatement {-# LINE 15066 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 15071 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 15076 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) -- TriggerWhen ------------------------------------------------- {- visit 0: inherited attributes: cat : Catalog 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 = Catalog -> LocalIdentifierBindings -> ( TriggerWhen,TriggerWhen) data Inh_TriggerWhen = Inh_TriggerWhen {cat_Inh_TriggerWhen :: Catalog,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 _lhsIcat _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIcat _lhsIlib ) in (Syn_TriggerWhen _lhsOannotatedTree _lhsOoriginalTree )) sem_TriggerWhen_TriggerAfter :: T_TriggerWhen sem_TriggerWhen_TriggerAfter = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: TriggerWhen _lhsOoriginalTree :: TriggerWhen -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} TriggerAfter {-# LINE 15130 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} TriggerAfter {-# LINE 15135 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 15140 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 15145 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_TriggerWhen_TriggerBefore :: T_TriggerWhen sem_TriggerWhen_TriggerBefore = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: TriggerWhen _lhsOoriginalTree :: TriggerWhen -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} TriggerBefore {-# LINE 15157 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} TriggerBefore {-# LINE 15162 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 15167 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 15172 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) -- TypeAttributeDef -------------------------------------------- {- visit 0: inherited attributes: cat : Catalog 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 = Catalog -> LocalIdentifierBindings -> ( TypeAttributeDef,String,Type,TypeAttributeDef) data Inh_TypeAttributeDef = Inh_TypeAttributeDef {cat_Inh_TypeAttributeDef :: Catalog,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 _lhsIcat _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOattrName,_lhsOnamedType,_lhsOoriginalTree) = (sem _lhsIcat _lhsIlib ) in (Syn_TypeAttributeDef _lhsOannotatedTree _lhsOattrName _lhsOnamedType _lhsOoriginalTree )) sem_TypeAttributeDef_TypeAttDef :: Annotation -> String -> T_TypeName -> T_TypeAttributeDef sem_TypeAttributeDef_TypeAttDef ann_ name_ typ_ = (\ _lhsIcat _lhsIlib -> (let _lhsOattrName :: String _lhsOnamedType :: Type _lhsOannotatedTree :: TypeAttributeDef _lhsOoriginalTree :: TypeAttributeDef _typOcat :: Catalog _typOlib :: LocalIdentifierBindings _typIannotatedTree :: TypeName _typInamedType :: Type _typIoriginalTree :: TypeName -- "./TypeChecking/MiscCreates.ag"(line 40, column 9) _lhsOattrName = {-# LINE 40 "./TypeChecking/MiscCreates.ag" #-} name_ {-# LINE 15234 "AstInternal.hs" #-} -- "./TypeChecking/MiscCreates.ag"(line 41, column 9) _lhsOnamedType = {-# LINE 41 "./TypeChecking/MiscCreates.ag" #-} _typInamedType {-# LINE 15239 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} TypeAttDef ann_ name_ _typIannotatedTree {-# LINE 15244 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} TypeAttDef ann_ name_ _typIoriginalTree {-# LINE 15249 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 15254 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 15259 "AstInternal.hs" #-} -- copy rule (down) _typOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 15264 "AstInternal.hs" #-} -- copy rule (down) _typOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 15269 "AstInternal.hs" #-} ( _typIannotatedTree,_typInamedType,_typIoriginalTree) = (typ_ _typOcat _typOlib ) in ( _lhsOannotatedTree,_lhsOattrName,_lhsOnamedType,_lhsOoriginalTree))) -- TypeAttributeDefList ---------------------------------------- {- visit 0: inherited attributes: cat : Catalog 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 = Catalog -> LocalIdentifierBindings -> ( TypeAttributeDefList,([(String, Type)]),TypeAttributeDefList) data Inh_TypeAttributeDefList = Inh_TypeAttributeDefList {cat_Inh_TypeAttributeDefList :: Catalog,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 _lhsIcat _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOattrs,_lhsOoriginalTree) = (sem _lhsIcat _lhsIlib ) in (Syn_TypeAttributeDefList _lhsOannotatedTree _lhsOattrs _lhsOoriginalTree )) sem_TypeAttributeDefList_Cons :: T_TypeAttributeDef -> T_TypeAttributeDefList -> T_TypeAttributeDefList sem_TypeAttributeDefList_Cons hd_ tl_ = (\ _lhsIcat _lhsIlib -> (let _lhsOattrs :: ([(String, Type)]) _lhsOannotatedTree :: TypeAttributeDefList _lhsOoriginalTree :: TypeAttributeDefList _hdOcat :: Catalog _hdOlib :: LocalIdentifierBindings _tlOcat :: Catalog _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 15338 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} (:) _hdIannotatedTree _tlIannotatedTree {-# LINE 15343 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} (:) _hdIoriginalTree _tlIoriginalTree {-# LINE 15348 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 15353 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 15358 "AstInternal.hs" #-} -- copy rule (down) _hdOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 15363 "AstInternal.hs" #-} -- copy rule (down) _hdOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 15368 "AstInternal.hs" #-} -- copy rule (down) _tlOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 15373 "AstInternal.hs" #-} -- copy rule (down) _tlOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 15378 "AstInternal.hs" #-} ( _hdIannotatedTree,_hdIattrName,_hdInamedType,_hdIoriginalTree) = (hd_ _hdOcat _hdOlib ) ( _tlIannotatedTree,_tlIattrs,_tlIoriginalTree) = (tl_ _tlOcat _tlOlib ) in ( _lhsOannotatedTree,_lhsOattrs,_lhsOoriginalTree))) sem_TypeAttributeDefList_Nil :: T_TypeAttributeDefList sem_TypeAttributeDefList_Nil = (\ _lhsIcat _lhsIlib -> (let _lhsOattrs :: ([(String, Type)]) _lhsOannotatedTree :: TypeAttributeDefList _lhsOoriginalTree :: TypeAttributeDefList -- "./TypeChecking/MiscCreates.ag"(line 47, column 11) _lhsOattrs = {-# LINE 47 "./TypeChecking/MiscCreates.ag" #-} [] {-# LINE 15395 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 15400 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 15405 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 15410 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 15415 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOattrs,_lhsOoriginalTree))) -- TypeName ---------------------------------------------------- {- visit 0: inherited attributes: cat : Catalog 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 = Catalog -> LocalIdentifierBindings -> ( TypeName,Type,TypeName) data Inh_TypeName = Inh_TypeName {cat_Inh_TypeName :: Catalog,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 _lhsIcat _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOnamedType,_lhsOoriginalTree) = (sem _lhsIcat _lhsIlib ) in (Syn_TypeName _lhsOannotatedTree _lhsOnamedType _lhsOoriginalTree )) sem_TypeName_ArrayTypeName :: Annotation -> T_TypeName -> T_TypeName sem_TypeName_ArrayTypeName ann_ typ_ = (\ _lhsIcat _lhsIlib -> (let _lhsOnamedType :: Type _lhsOannotatedTree :: TypeName _lhsOoriginalTree :: TypeName _typOcat :: Catalog _typOlib :: LocalIdentifierBindings _typIannotatedTree :: TypeName _typInamedType :: Type _typIoriginalTree :: TypeName -- "./TypeChecking/Misc.ag"(line 19, column 10) _lhsOnamedType = {-# LINE 19 "./TypeChecking/Misc.ag" #-} tpeToT _tpe {-# LINE 15509 "AstInternal.hs" #-} -- "./TypeChecking/Misc.ag"(line 20, column 10) _lhsOannotatedTree = {-# LINE 20 "./TypeChecking/Misc.ag" #-} updateAnnotation ((map TypeErrorA $ getErrors _tpe ) ++) _backTree {-# LINE 15516 "AstInternal.hs" #-} -- "./TypeChecking/Misc.ag"(line 30, column 9) _tpe = {-# LINE 30 "./TypeChecking/Misc.ag" #-} dependsOnRTpe [_typInamedType] $ Right $ ArrayType _typInamedType {-# LINE 15521 "AstInternal.hs" #-} -- "./TypeChecking/Misc.ag"(line 31, column 9) _backTree = {-# LINE 31 "./TypeChecking/Misc.ag" #-} ArrayTypeName ann_ _typIannotatedTree {-# LINE 15526 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} ArrayTypeName ann_ _typIannotatedTree {-# LINE 15531 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} ArrayTypeName ann_ _typIoriginalTree {-# LINE 15536 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 15541 "AstInternal.hs" #-} -- copy rule (down) _typOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 15546 "AstInternal.hs" #-} -- copy rule (down) _typOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 15551 "AstInternal.hs" #-} ( _typIannotatedTree,_typInamedType,_typIoriginalTree) = (typ_ _typOcat _typOlib ) in ( _lhsOannotatedTree,_lhsOnamedType,_lhsOoriginalTree))) sem_TypeName_PrecTypeName :: Annotation -> String -> Integer -> T_TypeName sem_TypeName_PrecTypeName ann_ tn_ prec_ = (\ _lhsIcat _lhsIlib -> (let _lhsOnamedType :: Type _lhsOannotatedTree :: TypeName _lhsOoriginalTree :: TypeName -- "./TypeChecking/Misc.ag"(line 19, column 10) _lhsOnamedType = {-# LINE 19 "./TypeChecking/Misc.ag" #-} tpeToT _tpe {-# LINE 15569 "AstInternal.hs" #-} -- "./TypeChecking/Misc.ag"(line 20, column 10) _lhsOannotatedTree = {-# LINE 20 "./TypeChecking/Misc.ag" #-} updateAnnotation ((map TypeErrorA $ getErrors _tpe ) ++) _backTree {-# LINE 15576 "AstInternal.hs" #-} -- "./TypeChecking/Misc.ag"(line 36, column 9) _tpe = {-# LINE 36 "./TypeChecking/Misc.ag" #-} catLookupType _lhsIcat $ canonicalizeTypeName tn_ {-# LINE 15581 "AstInternal.hs" #-} -- "./TypeChecking/Misc.ag"(line 37, column 9) _backTree = {-# LINE 37 "./TypeChecking/Misc.ag" #-} PrecTypeName ann_ tn_ prec_ {-# LINE 15586 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} PrecTypeName ann_ tn_ prec_ {-# LINE 15591 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} PrecTypeName ann_ tn_ prec_ {-# LINE 15596 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 15601 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOnamedType,_lhsOoriginalTree))) sem_TypeName_SetOfTypeName :: Annotation -> T_TypeName -> T_TypeName sem_TypeName_SetOfTypeName ann_ typ_ = (\ _lhsIcat _lhsIlib -> (let _lhsOnamedType :: Type _lhsOannotatedTree :: TypeName _lhsOoriginalTree :: TypeName _typOcat :: Catalog _typOlib :: LocalIdentifierBindings _typIannotatedTree :: TypeName _typInamedType :: Type _typIoriginalTree :: TypeName -- "./TypeChecking/Misc.ag"(line 19, column 10) _lhsOnamedType = {-# LINE 19 "./TypeChecking/Misc.ag" #-} tpeToT _tpe {-# LINE 15621 "AstInternal.hs" #-} -- "./TypeChecking/Misc.ag"(line 20, column 10) _lhsOannotatedTree = {-# LINE 20 "./TypeChecking/Misc.ag" #-} updateAnnotation ((map TypeErrorA $ getErrors _tpe ) ++) _backTree {-# LINE 15628 "AstInternal.hs" #-} -- "./TypeChecking/Misc.ag"(line 33, column 9) _tpe = {-# LINE 33 "./TypeChecking/Misc.ag" #-} dependsOnRTpe [_typInamedType] $ Right $ SetOfType _typInamedType {-# LINE 15633 "AstInternal.hs" #-} -- "./TypeChecking/Misc.ag"(line 34, column 9) _backTree = {-# LINE 34 "./TypeChecking/Misc.ag" #-} SetOfTypeName ann_ _typIannotatedTree {-# LINE 15638 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} SetOfTypeName ann_ _typIannotatedTree {-# LINE 15643 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} SetOfTypeName ann_ _typIoriginalTree {-# LINE 15648 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 15653 "AstInternal.hs" #-} -- copy rule (down) _typOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 15658 "AstInternal.hs" #-} -- copy rule (down) _typOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 15663 "AstInternal.hs" #-} ( _typIannotatedTree,_typInamedType,_typIoriginalTree) = (typ_ _typOcat _typOlib ) in ( _lhsOannotatedTree,_lhsOnamedType,_lhsOoriginalTree))) sem_TypeName_SimpleTypeName :: Annotation -> String -> T_TypeName sem_TypeName_SimpleTypeName ann_ tn_ = (\ _lhsIcat _lhsIlib -> (let _lhsOnamedType :: Type _lhsOannotatedTree :: TypeName _lhsOoriginalTree :: TypeName -- "./TypeChecking/Misc.ag"(line 19, column 10) _lhsOnamedType = {-# LINE 19 "./TypeChecking/Misc.ag" #-} tpeToT _tpe {-# LINE 15680 "AstInternal.hs" #-} -- "./TypeChecking/Misc.ag"(line 20, column 10) _lhsOannotatedTree = {-# LINE 20 "./TypeChecking/Misc.ag" #-} updateAnnotation ((map TypeErrorA $ getErrors _tpe ) ++) _backTree {-# LINE 15687 "AstInternal.hs" #-} -- "./TypeChecking/Misc.ag"(line 27, column 9) _tpe = {-# LINE 27 "./TypeChecking/Misc.ag" #-} catLookupType _lhsIcat $ canonicalizeTypeName tn_ {-# LINE 15692 "AstInternal.hs" #-} -- "./TypeChecking/Misc.ag"(line 28, column 9) _backTree = {-# LINE 28 "./TypeChecking/Misc.ag" #-} SimpleTypeName ann_ tn_ {-# LINE 15697 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} SimpleTypeName ann_ tn_ {-# LINE 15702 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} SimpleTypeName ann_ tn_ {-# LINE 15707 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 15712 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOnamedType,_lhsOoriginalTree))) -- TypeNameList ------------------------------------------------ {- visit 0: inherited attributes: cat : Catalog 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 = Catalog -> LocalIdentifierBindings -> ( TypeNameList,([Type]),TypeNameList) data Inh_TypeNameList = Inh_TypeNameList {cat_Inh_TypeNameList :: Catalog,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 _lhsIcat _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOnamedTypes,_lhsOoriginalTree) = (sem _lhsIcat _lhsIlib ) in (Syn_TypeNameList _lhsOannotatedTree _lhsOnamedTypes _lhsOoriginalTree )) sem_TypeNameList_Cons :: T_TypeName -> T_TypeNameList -> T_TypeNameList sem_TypeNameList_Cons hd_ tl_ = (\ _lhsIcat _lhsIlib -> (let _lhsOnamedTypes :: ([Type]) _lhsOannotatedTree :: TypeNameList _lhsOoriginalTree :: TypeNameList _hdOcat :: Catalog _hdOlib :: LocalIdentifierBindings _tlOcat :: Catalog _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 15778 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} (:) _hdIannotatedTree _tlIannotatedTree {-# LINE 15783 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} (:) _hdIoriginalTree _tlIoriginalTree {-# LINE 15788 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 15793 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 15798 "AstInternal.hs" #-} -- copy rule (down) _hdOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 15803 "AstInternal.hs" #-} -- copy rule (down) _hdOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 15808 "AstInternal.hs" #-} -- copy rule (down) _tlOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 15813 "AstInternal.hs" #-} -- copy rule (down) _tlOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 15818 "AstInternal.hs" #-} ( _hdIannotatedTree,_hdInamedType,_hdIoriginalTree) = (hd_ _hdOcat _hdOlib ) ( _tlIannotatedTree,_tlInamedTypes,_tlIoriginalTree) = (tl_ _tlOcat _tlOlib ) in ( _lhsOannotatedTree,_lhsOnamedTypes,_lhsOoriginalTree))) sem_TypeNameList_Nil :: T_TypeNameList sem_TypeNameList_Nil = (\ _lhsIcat _lhsIlib -> (let _lhsOnamedTypes :: ([Type]) _lhsOannotatedTree :: TypeNameList _lhsOoriginalTree :: TypeNameList -- "./TypeChecking/Drops.ag"(line 31, column 11) _lhsOnamedTypes = {-# LINE 31 "./TypeChecking/Drops.ag" #-} [] {-# LINE 15835 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 15840 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 15845 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 15850 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 15855 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOnamedTypes,_lhsOoriginalTree))) -- VarDef ------------------------------------------------------ {- visit 0: inherited attributes: cat : Catalog 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 = Catalog -> LocalIdentifierBindings -> ( VarDef,((String,Type)),VarDef) data Inh_VarDef = Inh_VarDef {cat_Inh_VarDef :: Catalog,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 _lhsIcat _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOdef,_lhsOoriginalTree) = (sem _lhsIcat _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_ = (\ _lhsIcat _lhsIlib -> (let _lhsOdef :: ((String,Type)) _lhsOannotatedTree :: VarDef _lhsOoriginalTree :: VarDef _typOcat :: Catalog _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 15917 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} VarDef ann_ name_ _typIannotatedTree value_ {-# LINE 15922 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} VarDef ann_ name_ _typIoriginalTree value_ {-# LINE 15927 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 15932 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 15937 "AstInternal.hs" #-} -- copy rule (down) _typOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 15942 "AstInternal.hs" #-} -- copy rule (down) _typOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 15947 "AstInternal.hs" #-} ( _typIannotatedTree,_typInamedType,_typIoriginalTree) = (typ_ _typOcat _typOlib ) in ( _lhsOannotatedTree,_lhsOdef,_lhsOoriginalTree))) -- VarDefList -------------------------------------------------- {- visit 0: inherited attributes: cat : Catalog 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 = Catalog -> LocalIdentifierBindings -> ( VarDefList,([(String,Type)]),VarDefList) data Inh_VarDefList = Inh_VarDefList {cat_Inh_VarDefList :: Catalog,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 _lhsIcat _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOdefs,_lhsOoriginalTree) = (sem _lhsIcat _lhsIlib ) in (Syn_VarDefList _lhsOannotatedTree _lhsOdefs _lhsOoriginalTree )) sem_VarDefList_Cons :: T_VarDef -> T_VarDefList -> T_VarDefList sem_VarDefList_Cons hd_ tl_ = (\ _lhsIcat _lhsIlib -> (let _lhsOdefs :: ([(String,Type)]) _lhsOannotatedTree :: VarDefList _lhsOoriginalTree :: VarDefList _hdOcat :: Catalog _hdOlib :: LocalIdentifierBindings _tlOcat :: Catalog _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 16015 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} (:) _hdIannotatedTree _tlIannotatedTree {-# LINE 16020 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} (:) _hdIoriginalTree _tlIoriginalTree {-# LINE 16025 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 16030 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 16035 "AstInternal.hs" #-} -- copy rule (down) _hdOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 16040 "AstInternal.hs" #-} -- copy rule (down) _hdOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 16045 "AstInternal.hs" #-} -- copy rule (down) _tlOcat = {-# LINE 56 "./TypeChecking/TypeChecking.ag" #-} _lhsIcat {-# LINE 16050 "AstInternal.hs" #-} -- copy rule (down) _tlOlib = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _lhsIlib {-# LINE 16055 "AstInternal.hs" #-} ( _hdIannotatedTree,_hdIdef,_hdIoriginalTree) = (hd_ _hdOcat _hdOlib ) ( _tlIannotatedTree,_tlIdefs,_tlIoriginalTree) = (tl_ _tlOcat _tlOlib ) in ( _lhsOannotatedTree,_lhsOdefs,_lhsOoriginalTree))) sem_VarDefList_Nil :: T_VarDefList sem_VarDefList_Nil = (\ _lhsIcat _lhsIlib -> (let _lhsOdefs :: ([(String,Type)]) _lhsOannotatedTree :: VarDefList _lhsOoriginalTree :: VarDefList -- "./TypeChecking/CreateFunction.ag"(line 135, column 11) _lhsOdefs = {-# LINE 135 "./TypeChecking/CreateFunction.ag" #-} [] {-# LINE 16072 "AstInternal.hs" #-} -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 16077 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} [] {-# LINE 16082 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 16087 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 16092 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOdefs,_lhsOoriginalTree))) -- Volatility -------------------------------------------------- {- visit 0: inherited attributes: cat : Catalog 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 = Catalog -> LocalIdentifierBindings -> ( Volatility,Volatility) data Inh_Volatility = Inh_Volatility {cat_Inh_Volatility :: Catalog,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 _lhsIcat _lhsIlib ) = (let ( _lhsOannotatedTree,_lhsOoriginalTree) = (sem _lhsIcat _lhsIlib ) in (Syn_Volatility _lhsOannotatedTree _lhsOoriginalTree )) sem_Volatility_Immutable :: T_Volatility sem_Volatility_Immutable = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: Volatility _lhsOoriginalTree :: Volatility -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Immutable {-# LINE 16153 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Immutable {-# LINE 16158 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 16163 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 16168 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_Volatility_Stable :: T_Volatility sem_Volatility_Stable = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: Volatility _lhsOoriginalTree :: Volatility -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Stable {-# LINE 16180 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Stable {-# LINE 16185 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 16190 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 16195 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree))) sem_Volatility_Volatile :: T_Volatility sem_Volatility_Volatile = (\ _lhsIcat _lhsIlib -> (let _lhsOannotatedTree :: Volatility _lhsOoriginalTree :: Volatility -- self rule _annotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} Volatile {-# LINE 16207 "AstInternal.hs" #-} -- self rule _originalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} Volatile {-# LINE 16212 "AstInternal.hs" #-} -- self rule _lhsOannotatedTree = {-# LINE 57 "./TypeChecking/TypeChecking.ag" #-} _annotatedTree {-# LINE 16217 "AstInternal.hs" #-} -- self rule _lhsOoriginalTree = {-# LINE 63 "./TypeChecking/TypeChecking.ag" #-} _originalTree {-# LINE 16222 "AstInternal.hs" #-} in ( _lhsOannotatedTree,_lhsOoriginalTree)))